/*
 * MATLAB Compiler: 3.0
 * Date: Mon Sep 20 09:37:02 2004
 * Arguments: "-B" "macro_default" "-O" "all" "-O" "fold_scalar_mxarrays:on"
 * "-O" "fold_non_scalar_mxarrays:on" "-O" "optimize_integer_for_loops:on" "-O"
 * "array_indexing:on" "-O" "optimize_conditionals:on" "-B" "sgl" "-m" "-W"
 * "main" "-L" "C" "-t" "-T" "link:exe" "-h" "libmmfile.mlib" "-W" "mainhg"
 * "libmwsglm.mlib" "RECARGA_2_3" 
 */
#include "recarga_2_3.h"
#include "dlmread.h"
#include "gui_mainfcn.h"
#include "guidata.h"
#include "imread.h"
#include "libmatlbm.h"
#include "libmmfile.h"
#include "libmwsglm.h"
#include "recarga.h"
#include "recarga_us.h"
#include "textread.h"
static mxArray * _mxarray0_;

static mxChar _array2_[8] = { 'g', 'u', 'i', '_', 'N', 'a', 'm', 'e' };
static mxArray * _mxarray1_;

static mxChar _array4_[13] = { 'g', 'u', 'i', '_', 'S', 'i', 'n',
                               'g', 'l', 'e', 't', 'o', 'n' };
static mxArray * _mxarray3_;

static mxChar _array6_[14] = { 'g', 'u', 'i', '_', 'O', 'p', 'e',
                               'n', 'i', 'n', 'g', 'F', 'c', 'n' };
static mxArray * _mxarray5_;

static mxChar _array8_[13] = { 'g', 'u', 'i', '_', 'O', 'u', 't',
                               'p', 'u', 't', 'F', 'c', 'n' };
static mxArray * _mxarray7_;

static mxChar _array10_[13] = { 'g', 'u', 'i', '_', 'L', 'a', 'y',
                                'o', 'u', 't', 'F', 'c', 'n' };
static mxArray * _mxarray9_;
static mxArray * _mxarray11_;

static mxChar _array13_[12] = { 'g', 'u', 'i', '_', 'C', 'a',
                                'l', 'l', 'b', 'a', 'c', 'k' };
static mxArray * _mxarray12_;

static mxChar _array15_[5] = { 'U', 'n', 'i', 't', 's' };
static mxArray * _mxarray14_;

static mxChar _array17_[10] = { 'n', 'o', 'r', 'm', 'a',
                                'l', 'i', 'z', 'e', 'd' };
static mxArray * _mxarray16_;

static mxChar _array19_[6] = { 'R', 'G', '.', 'j', 'p', 'g' };
static mxArray * _mxarray18_;

static mxChar _array21_[8] = { 'P', 'o', 's', 'i', 't', 'i', 'o', 'n' };
static mxArray * _mxarray20_;

static mxChar _array23_[7] = { 'V', 'i', 's', 'i', 'b', 'l', 'e' };
static mxArray * _mxarray22_;

static mxChar _array25_[3] = { 'o', 'f', 'f' };
static mxArray * _mxarray24_;

static mxChar _array27_[10] = { 'R', 'G', 'P', 'r', 'o',
                                'f', '.', 'j', 'p', 'g' };
static mxArray * _mxarray26_;

static mxChar _array29_[15] = { 'B', 'a', 'c', 'k', 'g', 'r', 'o', 'u',
                                'n', 'd', 'C', 'o', 'l', 'o', 'r' };
static mxArray * _mxarray28_;

static mxChar _array31_[5] = { 'w', 'h', 'i', 't', 'e' };
static mxArray * _mxarray30_;
static mxArray * _mxarray32_;

static mxChar _array34_[31] = { 'd', 'e', 'f', 'a', 'u', 'l', 't', 'U',
                                'i', 'c', 'o', 'n', 't', 'r', 'o', 'l',
                                'B', 'a', 'c', 'k', 'g', 'r', 'o', 'u',
                                'n', 'd', 'C', 'o', 'l', 'o', 'r' };
static mxArray * _mxarray33_;

static mxChar _array36_[6] = { 'S', 't', 'r', 'i', 'n', 'g' };
static mxArray * _mxarray35_;
static mxArray * _mxarray37_;
static mxArray * _mxarray38_;
static mxArray * _mxarray39_;
static mxArray * _mxarray40_;
static mxArray * _mxarray41_;
static mxArray * _mxarray42_;
static mxArray * _mxarray43_;

static mxChar _array45_[5] = { 'V', 'a', 'l', 'u', 'e' };
static mxArray * _mxarray44_;
static mxArray * _mxarray46_;
static mxArray * _mxarray47_;
static mxArray * _mxarray48_;
static mxArray * _mxarray49_;
static mxArray * _mxarray50_;

static mxChar _array52_[12] = { 's', 'o', 'i', 'l', 's', 'D',
                                'N', 'R', '.', 't', 'x', 't' };
static mxArray * _mxarray51_;

static mxChar _array54_[2] = { 0x005c, 't' };
static mxArray * _mxarray53_;

static double _array56_[4] = { 0.0, 1.0, 10.0, 4.0 };
static mxArray * _mxarray55_;

static mxChar _array58_[11] = { 's', 'o', 'i', 'l', 's', 'U',
                                'S', '.', 't', 'x', 't' };
static mxArray * _mxarray57_;

static mxChar _array60_[13] = { 's', 'o', 'i', 'l', 's', 'l', 'i',
                                's', 't', '.', 't', 'x', 't' };
static mxArray * _mxarray59_;

static mxChar _array62_[2] = { '%', 's' };
static mxArray * _mxarray61_;

static mxChar _array64_[9] = { 'd', 'e', 'l', 'i', 'm', 'i', 't', 'e', 'r' };
static mxArray * _mxarray63_;

static mxChar _array66_[2] = { 0x005c, 'n' };
static mxArray * _mxarray65_;

static mxChar _array68_[10] = { 'w', 'h', 'i', 't', 'e',
                                's', 'p', 'a', 'c', 'e' };
static mxArray * _mxarray67_;
static mxArray * _mxarray69_;
static mxArray * _mxarray70_;
static mxArray * _mxarray71_;
static mxArray * _mxarray72_;
static mxArray * _mxarray73_;
static mxArray * _mxarray74_;

static mxChar _array76_[4] = { '.', 't', 'x', 't' };
static mxArray * _mxarray75_;

static mxChar _array78_[5] = { 'T', 'y', 'p', 'e', 'I' };
static mxArray * _mxarray77_;

static mxChar _array80_[6] = { 'T', 'y', 'p', 'e', 'I', 'A' };
static mxArray * _mxarray79_;

static mxChar _array82_[6] = { 'T', 'y', 'p', 'e', 'I', 'I' };
static mxArray * _mxarray81_;

static mxChar _array84_[7] = { 'T', 'y', 'p', 'e', 'I', 'I', 'I' };
static mxArray * _mxarray83_;
static mxArray * _mxarray85_;

static mxChar _array87_[1] = { '0' };
static mxArray * _mxarray86_;
static mxArray * _mxarray88_;

static mxChar _array90_[2] = { 'o', 'n' };
static mxArray * _mxarray89_;
static mxArray * _mxarray91_;
static mxArray * _mxarray92_;
static mxArray * _mxarray93_;
static mxArray * _mxarray94_;
static mxArray * _mxarray95_;
static mxArray * _mxarray96_;
static mxArray * _mxarray97_;

static mxChar _array99_[6] = { 's', 't', 'r', 'i', 'n', 'g' };
static mxArray * _mxarray98_;

static double _array101_[5] = { .01, .05, .1, .15, .25 };
static mxArray * _mxarray100_;
static mxArray * _mxarray102_;
static mxArray * _mxarray103_;
static mxArray * _mxarray104_;
static mxArray * _mxarray105_;
static mxArray * _mxarray106_;
static mxArray * _mxarray107_;

void InitializeModule_recarga_2_3(void) {
    _mxarray0_ = mclInitializeDouble(1.0);
    _mxarray1_ = mclInitializeString(8, _array2_);
    _mxarray3_ = mclInitializeString(13, _array4_);
    _mxarray5_ = mclInitializeString(14, _array6_);
    _mxarray7_ = mclInitializeString(13, _array8_);
    _mxarray9_ = mclInitializeString(13, _array10_);
    _mxarray11_ = mclInitializeDoubleVector(0, 0, (double *)NULL);
    _mxarray12_ = mclInitializeString(12, _array13_);
    _mxarray14_ = mclInitializeString(5, _array15_);
    _mxarray16_ = mclInitializeString(10, _array17_);
    _mxarray18_ = mclInitializeString(6, _array19_);
    _mxarray20_ = mclInitializeString(8, _array21_);
    _mxarray22_ = mclInitializeString(7, _array23_);
    _mxarray24_ = mclInitializeString(3, _array25_);
    _mxarray26_ = mclInitializeString(10, _array27_);
    _mxarray28_ = mclInitializeString(15, _array29_);
    _mxarray30_ = mclInitializeString(5, _array31_);
    _mxarray32_ = mclInitializeDouble(0.0);
    _mxarray33_ = mclInitializeString(31, _array34_);
    _mxarray35_ = mclInitializeString(6, _array36_);
    _mxarray37_ = mclInitializeDouble(100.0);
    _mxarray38_ = mclInitializeDouble(3600.0);
    _mxarray39_ = mclInitializeDouble(.62);
    _mxarray40_ = mclInitializeDouble(9.81);
    _mxarray41_ = mclInitializeDouble(3.1457);
    _mxarray42_ = mclInitializeDouble(2.0);
    _mxarray43_ = mclInitializeDouble(1000.0);
    _mxarray44_ = mclInitializeString(5, _array45_);
    _mxarray46_ = mclInitializeDouble(32.18503937007874);
    _mxarray47_ = mclInitializeDouble(12.0);
    _mxarray48_ = mclInitializeDouble(2000.0);
    _mxarray49_ = mclInitializeDouble(24.0);
    _mxarray50_ = mclInitializeDouble(.35);
    _mxarray51_ = mclInitializeString(12, _array52_);
    _mxarray53_ = mclInitializeString(2, _array54_);
    _mxarray55_ = mclInitializeDoubleVector(1, 4, _array56_);
    _mxarray57_ = mclInitializeString(11, _array58_);
    _mxarray59_ = mclInitializeString(13, _array60_);
    _mxarray61_ = mclInitializeString(2, _array62_);
    _mxarray63_ = mclInitializeString(9, _array64_);
    _mxarray65_ = mclInitializeString(2, _array66_);
    _mxarray67_ = mclInitializeString(10, _array68_);
    _mxarray69_ = mclInitializeCharVector(0, 0, (mxChar *)NULL);
    _mxarray70_ = mclInitializeDouble(10.0);
    _mxarray71_ = mclInitializeDouble(5.0);
    _mxarray72_ = mclInitializeDouble(3.0);
    _mxarray73_ = mclInitializeDouble(60.0);
    _mxarray74_ = mclInitializeDouble(15.0);
    _mxarray75_ = mclInitializeString(4, _array76_);
    _mxarray77_ = mclInitializeString(5, _array78_);
    _mxarray79_ = mclInitializeString(6, _array80_);
    _mxarray81_ = mclInitializeString(6, _array82_);
    _mxarray83_ = mclInitializeString(7, _array84_);
    _mxarray85_ = mclInitializeDouble(2.54);
    _mxarray86_ = mclInitializeString(1, _array87_);
    _mxarray88_ = mclInitializeDouble(4.0);
    _mxarray89_ = mclInitializeString(2, _array90_);
    _mxarray91_ = mclInitializeDouble(10.763910416709722);
    _mxarray92_ = mclInitializeDouble(.0002471053814671653);
    _mxarray93_ = mclInitializeDouble(.39370078740157477);
    _mxarray94_ = mclInitializeDouble(.0008107131937899125);
    _mxarray95_ = mclInitializeDouble(.09290304);
    _mxarray96_ = mclInitializeDouble(4046.8564223999997);
    _mxarray97_ = mclInitializeDouble(1233.48183754752);
    _mxarray98_ = mclInitializeString(6, _array99_);
    _mxarray100_ = mclInitializeDoubleVector(1, 5, _array101_);
    _mxarray102_ = mclInitializeDouble(43560.0);
    _mxarray103_ = mclInitializeDouble(.0001);
    _mxarray104_ = mclInitializeDouble(.02);
    _mxarray105_ = mclInitializeDouble(.01);
    _mxarray106_ = mclInitializeDouble(.03);
    _mxarray107_ = mclInitializeDouble(.04);
}

void TerminateModule_recarga_2_3(void) {
    mxDestroyArray(_mxarray107_);
    mxDestroyArray(_mxarray106_);
    mxDestroyArray(_mxarray105_);
    mxDestroyArray(_mxarray104_);
    mxDestroyArray(_mxarray103_);
    mxDestroyArray(_mxarray102_);
    mxDestroyArray(_mxarray100_);
    mxDestroyArray(_mxarray98_);
    mxDestroyArray(_mxarray97_);
    mxDestroyArray(_mxarray96_);
    mxDestroyArray(_mxarray95_);
    mxDestroyArray(_mxarray94_);
    mxDestroyArray(_mxarray93_);
    mxDestroyArray(_mxarray92_);
    mxDestroyArray(_mxarray91_);
    mxDestroyArray(_mxarray89_);
    mxDestroyArray(_mxarray88_);
    mxDestroyArray(_mxarray86_);
    mxDestroyArray(_mxarray85_);
    mxDestroyArray(_mxarray83_);
    mxDestroyArray(_mxarray81_);
    mxDestroyArray(_mxarray79_);
    mxDestroyArray(_mxarray77_);
    mxDestroyArray(_mxarray75_);
    mxDestroyArray(_mxarray74_);
    mxDestroyArray(_mxarray73_);
    mxDestroyArray(_mxarray72_);
    mxDestroyArray(_mxarray71_);
    mxDestroyArray(_mxarray70_);
    mxDestroyArray(_mxarray69_);
    mxDestroyArray(_mxarray67_);
    mxDestroyArray(_mxarray65_);
    mxDestroyArray(_mxarray63_);
    mxDestroyArray(_mxarray61_);
    mxDestroyArray(_mxarray59_);
    mxDestroyArray(_mxarray57_);
    mxDestroyArray(_mxarray55_);
    mxDestroyArray(_mxarray53_);
    mxDestroyArray(_mxarray51_);
    mxDestroyArray(_mxarray50_);
    mxDestroyArray(_mxarray49_);
    mxDestroyArray(_mxarray48_);
    mxDestroyArray(_mxarray47_);
    mxDestroyArray(_mxarray46_);
    mxDestroyArray(_mxarray44_);
    mxDestroyArray(_mxarray43_);
    mxDestroyArray(_mxarray42_);
    mxDestroyArray(_mxarray41_);
    mxDestroyArray(_mxarray40_);
    mxDestroyArray(_mxarray39_);
    mxDestroyArray(_mxarray38_);
    mxDestroyArray(_mxarray37_);
    mxDestroyArray(_mxarray35_);
    mxDestroyArray(_mxarray33_);
    mxDestroyArray(_mxarray32_);
    mxDestroyArray(_mxarray30_);
    mxDestroyArray(_mxarray28_);
    mxDestroyArray(_mxarray26_);
    mxDestroyArray(_mxarray24_);
    mxDestroyArray(_mxarray22_);
    mxDestroyArray(_mxarray20_);
    mxDestroyArray(_mxarray18_);
    mxDestroyArray(_mxarray16_);
    mxDestroyArray(_mxarray14_);
    mxDestroyArray(_mxarray12_);
    mxDestroyArray(_mxarray11_);
    mxDestroyArray(_mxarray9_);
    mxDestroyArray(_mxarray7_);
    mxDestroyArray(_mxarray5_);
    mxDestroyArray(_mxarray3_);
    mxDestroyArray(_mxarray1_);
    mxDestroyArray(_mxarray0_);
}

static void mlfRecarga_2_3_RECARGA_2_3_OpeningFcn(mxArray * hObject,
                                                  mxArray * eventdata,
                                                  mxArray * handles,
                                                  ...);
static void mlxRecarga_2_3_RECARGA_2_3_OpeningFcn(int nlhs,
                                                  mxArray * plhs[],
                                                  int nrhs,
                                                  mxArray * prhs[]);
static mxArray * mlfRecarga_2_3_RECARGA_2_3_OutputFcn(mlfVarargoutList * varargout,
                                                      mxArray * hObject,
                                                      mxArray * eventdata,
                                                      mxArray * handles);
static void mlxRecarga_2_3_RECARGA_2_3_OutputFcn(int nlhs,
                                                 mxArray * plhs[],
                                                 int nrhs,
                                                 mxArray * prhs[]);
static void mlfRecarga_2_3_Process_Callback(mxArray * hObject,
                                            mxArray * eventdata,
                                            mxArray * handles);
static void mlxRecarga_2_3_Process_Callback(int nlhs,
                                            mxArray * plhs[],
                                            int nrhs,
                                            mxArray * prhs[]);
static void mlfRecarga_2_3_Progress_CreateFcn(mxArray * hObject,
                                              mxArray * eventdata,
                                              mxArray * handles);
static void mlxRecarga_2_3_Progress_CreateFcn(int nlhs,
                                              mxArray * plhs[],
                                              int nrhs,
                                              mxArray * prhs[]);
static void mlfRecarga_2_3_Progress_Callback(mxArray * hObject,
                                             mxArray * eventdata,
                                             mxArray * handles);
static void mlxRecarga_2_3_Progress_Callback(int nlhs,
                                             mxArray * plhs[],
                                             int nrhs,
                                             mxArray * prhs[]);
static void mlfRecarga_2_3_Runon_CreateFcn(mxArray * hObject,
                                           mxArray * eventdata,
                                           mxArray * handles);
static void mlxRecarga_2_3_Runon_CreateFcn(int nlhs,
                                           mxArray * plhs[],
                                           int nrhs,
                                           mxArray * prhs[]);
static void mlfRecarga_2_3_Runon_Callback(mxArray * hObject,
                                          mxArray * eventdata,
                                          mxArray * handles);
static void mlxRecarga_2_3_Runon_Callback(int nlhs,
                                          mxArray * plhs[],
                                          int nrhs,
                                          mxArray * prhs[]);
static void mlfRecarga_2_3_Runoff_CreateFcn(mxArray * hObject,
                                            mxArray * eventdata,
                                            mxArray * handles);
static void mlxRecarga_2_3_Runoff_CreateFcn(int nlhs,
                                            mxArray * plhs[],
                                            int nrhs,
                                            mxArray * prhs[]);
static void mlfRecarga_2_3_Runoff_Callback(mxArray * hObject,
                                           mxArray * eventdata,
                                           mxArray * handles);
static void mlxRecarga_2_3_Runoff_Callback(int nlhs,
                                           mxArray * plhs[],
                                           int nrhs,
                                           mxArray * prhs[]);
static void mlfRecarga_2_3_Recharge_CreateFcn(mxArray * hObject,
                                              mxArray * eventdata,
                                              mxArray * handles);
static void mlxRecarga_2_3_Recharge_CreateFcn(int nlhs,
                                              mxArray * plhs[],
                                              int nrhs,
                                              mxArray * prhs[]);
static void mlfRecarga_2_3_Recharge_Callback(mxArray * hObject,
                                             mxArray * eventdata,
                                             mxArray * handles);
static void mlxRecarga_2_3_Recharge_Callback(int nlhs,
                                             mxArray * plhs[],
                                             int nrhs,
                                             mxArray * prhs[]);
static void mlfRecarga_2_3_Evap_CreateFcn(mxArray * hObject,
                                          mxArray * eventdata,
                                          mxArray * handles);
static void mlxRecarga_2_3_Evap_CreateFcn(int nlhs,
                                          mxArray * plhs[],
                                          int nrhs,
                                          mxArray * prhs[]);
static void mlfRecarga_2_3_Evap_Callback(mxArray * hObject,
                                         mxArray * eventdata,
                                         mxArray * handles);
static void mlxRecarga_2_3_Evap_Callback(int nlhs,
                                         mxArray * plhs[],
                                         int nrhs,
                                         mxArray * prhs[]);
static void mlfRecarga_2_3_Storage_CreateFcn(mxArray * hObject,
                                             mxArray * eventdata,
                                             mxArray * handles);
static void mlxRecarga_2_3_Storage_CreateFcn(int nlhs,
                                             mxArray * plhs[],
                                             int nrhs,
                                             mxArray * prhs[]);
static void mlfRecarga_2_3_Storage_Callback(mxArray * hObject,
                                            mxArray * eventdata,
                                            mxArray * handles);
static void mlxRecarga_2_3_Storage_Callback(int nlhs,
                                            mxArray * plhs[],
                                            int nrhs,
                                            mxArray * prhs[]);
static void mlfRecarga_2_3_Prunon_CreateFcn(mxArray * hObject,
                                            mxArray * eventdata,
                                            mxArray * handles);
static void mlxRecarga_2_3_Prunon_CreateFcn(int nlhs,
                                            mxArray * plhs[],
                                            int nrhs,
                                            mxArray * prhs[]);
static void mlfRecarga_2_3_Prunon_Callback(mxArray * hObject,
                                           mxArray * eventdata,
                                           mxArray * handles);
static void mlxRecarga_2_3_Prunon_Callback(int nlhs,
                                           mxArray * plhs[],
                                           int nrhs,
                                           mxArray * prhs[]);
static void mlfRecarga_2_3_Prunoff_CreateFcn(mxArray * hObject,
                                             mxArray * eventdata,
                                             mxArray * handles);
static void mlxRecarga_2_3_Prunoff_CreateFcn(int nlhs,
                                             mxArray * plhs[],
                                             int nrhs,
                                             mxArray * prhs[]);
static void mlfRecarga_2_3_Prunoff_Callback(mxArray * hObject,
                                            mxArray * eventdata,
                                            mxArray * handles);
static void mlxRecarga_2_3_Prunoff_Callback(int nlhs,
                                            mxArray * plhs[],
                                            int nrhs,
                                            mxArray * prhs[]);
static void mlfRecarga_2_3_Precharge_CreateFcn(mxArray * hObject,
                                               mxArray * eventdata,
                                               mxArray * handles);
static void mlxRecarga_2_3_Precharge_CreateFcn(int nlhs,
                                               mxArray * plhs[],
                                               int nrhs,
                                               mxArray * prhs[]);
static void mlfRecarga_2_3_Precharge_Callback(mxArray * hObject,
                                              mxArray * eventdata,
                                              mxArray * handles);
static void mlxRecarga_2_3_Precharge_Callback(int nlhs,
                                              mxArray * plhs[],
                                              int nrhs,
                                              mxArray * prhs[]);
static void mlfRecarga_2_3_Pevap_CreateFcn(mxArray * hObject,
                                           mxArray * eventdata,
                                           mxArray * handles);
static void mlxRecarga_2_3_Pevap_CreateFcn(int nlhs,
                                           mxArray * plhs[],
                                           int nrhs,
                                           mxArray * prhs[]);
static void mlfRecarga_2_3_Pevap_Callback(mxArray * hObject,
                                          mxArray * eventdata,
                                          mxArray * handles);
static void mlxRecarga_2_3_Pevap_Callback(int nlhs,
                                          mxArray * plhs[],
                                          int nrhs,
                                          mxArray * prhs[]);
static void mlfRecarga_2_3_maxpond_CreateFcn(mxArray * hObject,
                                             mxArray * eventdata,
                                             mxArray * handles);
static void mlxRecarga_2_3_maxpond_CreateFcn(int nlhs,
                                             mxArray * plhs[],
                                             int nrhs,
                                             mxArray * prhs[]);
static void mlfRecarga_2_3_maxpond_Callback(mxArray * hObject,
                                            mxArray * eventdata,
                                            mxArray * handles);
static void mlxRecarga_2_3_maxpond_Callback(int nlhs,
                                            mxArray * plhs[],
                                            int nrhs,
                                            mxArray * prhs[]);
static void mlfRecarga_2_3_maxwilt_CreateFcn(mxArray * hObject,
                                             mxArray * eventdata,
                                             mxArray * handles);
static void mlxRecarga_2_3_maxwilt_CreateFcn(int nlhs,
                                             mxArray * plhs[],
                                             int nrhs,
                                             mxArray * prhs[]);
static void mlfRecarga_2_3_maxwilt_Callback(mxArray * hObject,
                                            mxArray * eventdata,
                                            mxArray * handles);
static void mlxRecarga_2_3_maxwilt_Callback(int nlhs,
                                            mxArray * plhs[],
                                            int nrhs,
                                            mxArray * prhs[]);
static void mlfRecarga_2_3_tpond_CreateFcn(mxArray * hObject,
                                           mxArray * eventdata,
                                           mxArray * handles);
static void mlxRecarga_2_3_tpond_CreateFcn(int nlhs,
                                           mxArray * plhs[],
                                           int nrhs,
                                           mxArray * prhs[]);
static void mlfRecarga_2_3_tpond_Callback(mxArray * hObject,
                                          mxArray * eventdata,
                                          mxArray * handles);
static void mlxRecarga_2_3_tpond_Callback(int nlhs,
                                          mxArray * plhs[],
                                          int nrhs,
                                          mxArray * prhs[]);
static void mlfRecarga_2_3_OFtimes_CreateFcn(mxArray * hObject,
                                             mxArray * eventdata,
                                             mxArray * handles);
static void mlxRecarga_2_3_OFtimes_CreateFcn(int nlhs,
                                             mxArray * plhs[],
                                             int nrhs,
                                             mxArray * prhs[]);
static void mlfRecarga_2_3_OFtimes_Callback(mxArray * hObject,
                                            mxArray * eventdata,
                                            mxArray * handles);
static void mlxRecarga_2_3_OFtimes_Callback(int nlhs,
                                            mxArray * plhs[],
                                            int nrhs,
                                            mxArray * prhs[]);
static void mlfRecarga_2_3_ImpA_CreateFcn(mxArray * hObject,
                                          mxArray * eventdata,
                                          mxArray * handles);
static void mlxRecarga_2_3_ImpA_CreateFcn(int nlhs,
                                          mxArray * plhs[],
                                          int nrhs,
                                          mxArray * prhs[]);
static void mlfRecarga_2_3_ImpA_Callback(mxArray * hObject,
                                         mxArray * eventdata,
                                         mxArray * handles);
static void mlxRecarga_2_3_ImpA_Callback(int nlhs,
                                         mxArray * plhs[],
                                         int nrhs,
                                         mxArray * prhs[]);
static void mlfRecarga_2_3_CN_CreateFcn(mxArray * hObject,
                                        mxArray * eventdata,
                                        mxArray * handles);
static void mlxRecarga_2_3_CN_CreateFcn(int nlhs,
                                        mxArray * plhs[],
                                        int nrhs,
                                        mxArray * prhs[]);
static void mlfRecarga_2_3_CN_Callback(mxArray * hObject,
                                       mxArray * eventdata,
                                       mxArray * handles);
static void mlxRecarga_2_3_CN_Callback(int nlhs,
                                       mxArray * plhs[],
                                       int nrhs,
                                       mxArray * prhs[]);
static void mlfRecarga_2_3_ImpVol_CreateFcn(mxArray * hObject,
                                            mxArray * eventdata,
                                            mxArray * handles);
static void mlxRecarga_2_3_ImpVol_CreateFcn(int nlhs,
                                            mxArray * plhs[],
                                            int nrhs,
                                            mxArray * prhs[]);
static void mlfRecarga_2_3_ImpVol_Callback(mxArray * hObject,
                                           mxArray * eventdata,
                                           mxArray * handles);
static void mlxRecarga_2_3_ImpVol_Callback(int nlhs,
                                           mxArray * plhs[],
                                           int nrhs,
                                           mxArray * prhs[]);
static void mlfRecarga_2_3_PervVol_CreateFcn(mxArray * hObject,
                                             mxArray * eventdata,
                                             mxArray * handles);
static void mlxRecarga_2_3_PervVol_CreateFcn(int nlhs,
                                             mxArray * plhs[],
                                             int nrhs,
                                             mxArray * prhs[]);
static void mlfRecarga_2_3_PervVol_Callback(mxArray * hObject,
                                            mxArray * eventdata,
                                            mxArray * handles);
static void mlxRecarga_2_3_PervVol_Callback(int nlhs,
                                            mxArray * plhs[],
                                            int nrhs,
                                            mxArray * prhs[]);
static void mlfRecarga_2_3_ImpDpth_CreateFcn(mxArray * hObject,
                                             mxArray * eventdata,
                                             mxArray * handles);
static void mlxRecarga_2_3_ImpDpth_CreateFcn(int nlhs,
                                             mxArray * plhs[],
                                             int nrhs,
                                             mxArray * prhs[]);
static void mlfRecarga_2_3_ImpDpth_Callback(mxArray * hObject,
                                            mxArray * eventdata,
                                            mxArray * handles);
static void mlxRecarga_2_3_ImpDpth_Callback(int nlhs,
                                            mxArray * plhs[],
                                            int nrhs,
                                            mxArray * prhs[]);
static void mlfRecarga_2_3_PervDpth_CreateFcn(mxArray * hObject,
                                              mxArray * eventdata,
                                              mxArray * handles);
static void mlxRecarga_2_3_PervDpth_CreateFcn(int nlhs,
                                              mxArray * plhs[],
                                              int nrhs,
                                              mxArray * prhs[]);
static void mlfRecarga_2_3_PervDpth_Callback(mxArray * hObject,
                                             mxArray * eventdata,
                                             mxArray * handles);
static void mlxRecarga_2_3_PervDpth_Callback(int nlhs,
                                             mxArray * plhs[],
                                             int nrhs,
                                             mxArray * prhs[]);
static void mlfRecarga_2_3_RoffDpth_CreateFcn(mxArray * hObject,
                                              mxArray * eventdata,
                                              mxArray * handles);
static void mlxRecarga_2_3_RoffDpth_CreateFcn(int nlhs,
                                              mxArray * plhs[],
                                              int nrhs,
                                              mxArray * prhs[]);
static void mlfRecarga_2_3_RoffDpth_Callback(mxArray * hObject,
                                             mxArray * eventdata,
                                             mxArray * handles);
static void mlxRecarga_2_3_RoffDpth_Callback(int nlhs,
                                             mxArray * plhs[],
                                             int nrhs,
                                             mxArray * prhs[]);
static void mlfRecarga_2_3_RchrgDpth_CreateFcn(mxArray * hObject,
                                               mxArray * eventdata,
                                               mxArray * handles);
static void mlxRecarga_2_3_RchrgDpth_CreateFcn(int nlhs,
                                               mxArray * plhs[],
                                               int nrhs,
                                               mxArray * prhs[]);
static void mlfRecarga_2_3_RchrgDpth_Callback(mxArray * hObject,
                                              mxArray * eventdata,
                                              mxArray * handles);
static void mlxRecarga_2_3_RchrgDpth_Callback(int nlhs,
                                              mxArray * plhs[],
                                              int nrhs,
                                              mxArray * prhs[]);
static void mlfRecarga_2_3_EvapDpth_CreateFcn(mxArray * hObject,
                                              mxArray * eventdata,
                                              mxArray * handles);
static void mlxRecarga_2_3_EvapDpth_CreateFcn(int nlhs,
                                              mxArray * plhs[],
                                              int nrhs,
                                              mxArray * prhs[]);
static void mlfRecarga_2_3_EvapDpth_Callback(mxArray * hObject,
                                             mxArray * eventdata,
                                             mxArray * handles);
static void mlxRecarga_2_3_EvapDpth_Callback(int nlhs,
                                             mxArray * plhs[],
                                             int nrhs,
                                             mxArray * prhs[]);
static void mlfRecarga_2_3_RnOnDpth_CreateFcn(mxArray * hObject,
                                              mxArray * eventdata,
                                              mxArray * handles);
static void mlxRecarga_2_3_RnOnDpth_CreateFcn(int nlhs,
                                              mxArray * plhs[],
                                              int nrhs,
                                              mxArray * prhs[]);
static void mlfRecarga_2_3_RnOnDpth_Callback(mxArray * hObject,
                                             mxArray * eventdata,
                                             mxArray * handles);
static void mlxRecarga_2_3_RnOnDpth_Callback(int nlhs,
                                             mxArray * plhs[],
                                             int nrhs,
                                             mxArray * prhs[]);
static void mlfRecarga_2_3_UdVol_CreateFcn(mxArray * hObject,
                                           mxArray * eventdata,
                                           mxArray * handles);
static void mlxRecarga_2_3_UdVol_CreateFcn(int nlhs,
                                           mxArray * plhs[],
                                           int nrhs,
                                           mxArray * prhs[]);
static void mlfRecarga_2_3_UdVol_Callback(mxArray * hObject,
                                          mxArray * eventdata,
                                          mxArray * handles);
static void mlxRecarga_2_3_UdVol_Callback(int nlhs,
                                          mxArray * plhs[],
                                          int nrhs,
                                          mxArray * prhs[]);
static void mlfRecarga_2_3_UdFrac_CreateFcn(mxArray * hObject,
                                            mxArray * eventdata,
                                            mxArray * handles);
static void mlxRecarga_2_3_UdFrac_CreateFcn(int nlhs,
                                            mxArray * plhs[],
                                            int nrhs,
                                            mxArray * prhs[]);
static void mlfRecarga_2_3_UdFrac_Callback(mxArray * hObject,
                                           mxArray * eventdata,
                                           mxArray * handles);
static void mlxRecarga_2_3_UdFrac_Callback(int nlhs,
                                           mxArray * plhs[],
                                           int nrhs,
                                           mxArray * prhs[]);
static void mlfRecarga_2_3_UdDpth_CreateFcn(mxArray * hObject,
                                            mxArray * eventdata,
                                            mxArray * handles);
static void mlxRecarga_2_3_UdDpth_CreateFcn(int nlhs,
                                            mxArray * plhs[],
                                            int nrhs,
                                            mxArray * prhs[]);
static void mlfRecarga_2_3_UdDpth_Callback(mxArray * hObject,
                                           mxArray * eventdata,
                                           mxArray * handles);
static void mlxRecarga_2_3_UdDpth_Callback(int nlhs,
                                           mxArray * plhs[],
                                           int nrhs,
                                           mxArray * prhs[]);
static void mlfRecarga_2_3_UFlow_CreateFcn(mxArray * hObject,
                                           mxArray * eventdata,
                                           mxArray * handles);
static void mlxRecarga_2_3_UFlow_CreateFcn(int nlhs,
                                           mxArray * plhs[],
                                           int nrhs,
                                           mxArray * prhs[]);
static void mlfRecarga_2_3_UFlow_Callback(mxArray * hObject,
                                          mxArray * eventdata,
                                          mxArray * handles);
static void mlxRecarga_2_3_UFlow_Callback(int nlhs,
                                          mxArray * plhs[],
                                          int nrhs,
                                          mxArray * prhs[]);
static void mlfRecarga_2_3_BasinArea_CreateFcn(mxArray * hObject,
                                               mxArray * eventdata,
                                               mxArray * handles);
static void mlxRecarga_2_3_BasinArea_CreateFcn(int nlhs,
                                               mxArray * plhs[],
                                               int nrhs,
                                               mxArray * prhs[]);
static void mlfRecarga_2_3_BasinArea_Callback(mxArray * hObject,
                                              mxArray * eventdata,
                                              mxArray * handles);
static void mlxRecarga_2_3_BasinArea_Callback(int nlhs,
                                              mxArray * plhs[],
                                              int nrhs,
                                              mxArray * prhs[]);
static void mlfRecarga_2_3_Udiam_CreateFcn(mxArray * hObject,
                                           mxArray * eventdata,
                                           mxArray * handles);
static void mlxRecarga_2_3_Udiam_CreateFcn(int nlhs,
                                           mxArray * plhs[],
                                           int nrhs,
                                           mxArray * prhs[]);
static void mlfRecarga_2_3_Udiam_Callback(mxArray * hObject,
                                          mxArray * eventdata,
                                          mxArray * handles);
static void mlxRecarga_2_3_Udiam_Callback(int nlhs,
                                          mxArray * plhs[],
                                          int nrhs,
                                          mxArray * prhs[]);
static void mlfRecarga_2_3_AveET_CreateFcn(mxArray * hObject,
                                           mxArray * eventdata,
                                           mxArray * handles);
static void mlxRecarga_2_3_AveET_CreateFcn(int nlhs,
                                           mxArray * plhs[],
                                           int nrhs,
                                           mxArray * prhs[]);
static void mlfRecarga_2_3_AveET_Callback(mxArray * hObject,
                                          mxArray * eventdata,
                                          mxArray * handles);
static void mlxRecarga_2_3_AveET_Callback(int nlhs,
                                          mxArray * plhs[],
                                          int nrhs,
                                          mxArray * prhs[]);
static void mlfRecarga_2_3_Sd_CreateFcn(mxArray * hObject,
                                        mxArray * eventdata,
                                        mxArray * handles);
static void mlxRecarga_2_3_Sd_CreateFcn(int nlhs,
                                        mxArray * plhs[],
                                        int nrhs,
                                        mxArray * prhs[]);
static void mlfRecarga_2_3_Sd_Callback(mxArray * hObject,
                                       mxArray * eventdata,
                                       mxArray * handles);
static void mlxRecarga_2_3_Sd_Callback(int nlhs,
                                       mxArray * plhs[],
                                       int nrhs,
                                       mxArray * prhs[]);
static void mlfRecarga_2_3_Srz_CreateFcn(mxArray * hObject,
                                         mxArray * eventdata,
                                         mxArray * handles);
static void mlxRecarga_2_3_Srz_CreateFcn(int nlhs,
                                         mxArray * plhs[],
                                         int nrhs,
                                         mxArray * prhs[]);
static void mlfRecarga_2_3_Srz_Callback(mxArray * hObject,
                                        mxArray * eventdata,
                                        mxArray * handles);
static void mlxRecarga_2_3_Srz_Callback(int nlhs,
                                        mxArray * plhs[],
                                        int nrhs,
                                        mxArray * prhs[]);
static void mlfRecarga_2_3_St_CreateFcn(mxArray * hObject,
                                        mxArray * eventdata,
                                        mxArray * handles);
static void mlxRecarga_2_3_St_CreateFcn(int nlhs,
                                        mxArray * plhs[],
                                        int nrhs,
                                        mxArray * prhs[]);
static void mlfRecarga_2_3_St_Callback(mxArray * hObject,
                                       mxArray * eventdata,
                                       mxArray * handles);
static void mlxRecarga_2_3_St_Callback(int nlhs,
                                       mxArray * plhs[],
                                       int nrhs,
                                       mxArray * prhs[]);
static void mlfRecarga_2_3_Ksat_CreateFcn(mxArray * hObject,
                                          mxArray * eventdata,
                                          mxArray * handles);
static void mlxRecarga_2_3_Ksat_CreateFcn(int nlhs,
                                          mxArray * plhs[],
                                          int nrhs,
                                          mxArray * prhs[]);
static void mlfRecarga_2_3_Ksat_Callback(mxArray * hObject,
                                         mxArray * eventdata,
                                         mxArray * handles);
static void mlxRecarga_2_3_Ksat_Callback(int nlhs,
                                         mxArray * plhs[],
                                         int nrhs,
                                         mxArray * prhs[]);
static void mlfRecarga_2_3_Input_CreateFcn(mxArray * hObject,
                                           mxArray * eventdata,
                                           mxArray * handles);
static void mlxRecarga_2_3_Input_CreateFcn(int nlhs,
                                           mxArray * plhs[],
                                           int nrhs,
                                           mxArray * prhs[]);
static void mlfRecarga_2_3_Input_Callback(mxArray * hObject,
                                          mxArray * eventdata,
                                          mxArray * handles);
static void mlxRecarga_2_3_Input_Callback(int nlhs,
                                          mxArray * plhs[],
                                          int nrhs,
                                          mxArray * prhs[]);
static void mlfRecarga_2_3_edit9_CreateFcn(mxArray * hObject,
                                           mxArray * eventdata,
                                           mxArray * handles);
static void mlxRecarga_2_3_edit9_CreateFcn(int nlhs,
                                           mxArray * plhs[],
                                           int nrhs,
                                           mxArray * prhs[]);
static void mlfRecarga_2_3_edit9_Callback(mxArray * hObject,
                                          mxArray * eventdata,
                                          mxArray * handles);
static void mlxRecarga_2_3_edit9_Callback(int nlhs,
                                          mxArray * plhs[],
                                          int nrhs,
                                          mxArray * prhs[]);
static void mlfRecarga_2_3_popupmenu1_CreateFcn(mxArray * hObject,
                                                mxArray * eventdata,
                                                mxArray * handles);
static void mlxRecarga_2_3_popupmenu1_CreateFcn(int nlhs,
                                                mxArray * plhs[],
                                                int nrhs,
                                                mxArray * prhs[]);
static void mlfRecarga_2_3_popupmenu1_Callback(mxArray * hObject,
                                               mxArray * eventdata,
                                               mxArray * handles);
static void mlxRecarga_2_3_popupmenu1_Callback(int nlhs,
                                               mxArray * plhs[],
                                               int nrhs,
                                               mxArray * prhs[]);
static void mlfRecarga_2_3_Length_CreateFcn(mxArray * hObject,
                                            mxArray * eventdata,
                                            mxArray * handles);
static void mlxRecarga_2_3_Length_CreateFcn(int nlhs,
                                            mxArray * plhs[],
                                            int nrhs,
                                            mxArray * prhs[]);
static void mlfRecarga_2_3_Length_Callback(mxArray * hObject,
                                           mxArray * eventdata,
                                           mxArray * handles);
static void mlxRecarga_2_3_Length_Callback(int nlhs,
                                           mxArray * plhs[],
                                           int nrhs,
                                           mxArray * prhs[]);
static void mlfRecarga_2_3_Output_CreateFcn(mxArray * hObject,
                                            mxArray * eventdata,
                                            mxArray * handles);
static void mlxRecarga_2_3_Output_CreateFcn(int nlhs,
                                            mxArray * plhs[],
                                            int nrhs,
                                            mxArray * prhs[]);
static void mlfRecarga_2_3_Output_Callback(mxArray * hObject,
                                           mxArray * eventdata,
                                           mxArray * handles);
static void mlxRecarga_2_3_Output_Callback(int nlhs,
                                           mxArray * plhs[],
                                           int nrhs,
                                           mxArray * prhs[]);
static void mlfRecarga_2_3_Name_CreateFcn(mxArray * hObject,
                                          mxArray * eventdata,
                                          mxArray * handles);
static void mlxRecarga_2_3_Name_CreateFcn(int nlhs,
                                          mxArray * plhs[],
                                          int nrhs,
                                          mxArray * prhs[]);
static void mlfRecarga_2_3_Name_Callback(mxArray * hObject,
                                         mxArray * eventdata,
                                         mxArray * handles);
static void mlxRecarga_2_3_Name_Callback(int nlhs,
                                         mxArray * plhs[],
                                         int nrhs,
                                         mxArray * prhs[]);
static void mlfRecarga_2_3_RGArea_CreateFcn(mxArray * hObject,
                                            mxArray * eventdata,
                                            mxArray * handles);
static void mlxRecarga_2_3_RGArea_CreateFcn(int nlhs,
                                            mxArray * plhs[],
                                            int nrhs,
                                            mxArray * prhs[]);
static void mlfRecarga_2_3_RGArea_Callback(mxArray * hObject,
                                           mxArray * eventdata,
                                           mxArray * handles);
static void mlxRecarga_2_3_RGArea_Callback(int nlhs,
                                           mxArray * plhs[],
                                           int nrhs,
                                           mxArray * prhs[]);
static void mlfRecarga_2_3_RGCalc_Callback(mxArray * hObject,
                                           mxArray * eventdata,
                                           mxArray * handles);
static void mlxRecarga_2_3_RGCalc_Callback(int nlhs,
                                           mxArray * plhs[],
                                           int nrhs,
                                           mxArray * prhs[]);
static void mlfRecarga_2_3_Process_CreateFcn(mxArray * hObject,
                                             mxArray * eventdata,
                                             mxArray * handles);
static void mlxRecarga_2_3_Process_CreateFcn(int nlhs,
                                             mxArray * plhs[],
                                             int nrhs,
                                             mxArray * prhs[]);
static void mlfRecarga_2_3_clear_Callback(mxArray * hObject,
                                          mxArray * eventdata,
                                          mxArray * handles);
static void mlxRecarga_2_3_clear_Callback(int nlhs,
                                          mxArray * plhs[],
                                          int nrhs,
                                          mxArray * prhs[]);
static void mlfRecarga_2_3_RootTexture_CreateFcn(mxArray * hObject,
                                                 mxArray * eventdata,
                                                 mxArray * handles);
static void mlxRecarga_2_3_RootTexture_CreateFcn(int nlhs,
                                                 mxArray * plhs[],
                                                 int nrhs,
                                                 mxArray * prhs[]);
static void mlfRecarga_2_3_RootTexture_Callback(mxArray * hObject,
                                                mxArray * eventdata,
                                                mxArray * handles);
static void mlxRecarga_2_3_RootTexture_Callback(int nlhs,
                                                mxArray * plhs[],
                                                int nrhs,
                                                mxArray * prhs[]);
static void mlfRecarga_2_3_StorageTexture_CreateFcn(mxArray * hObject,
                                                    mxArray * eventdata,
                                                    mxArray * handles);
static void mlxRecarga_2_3_StorageTexture_CreateFcn(int nlhs,
                                                    mxArray * plhs[],
                                                    int nrhs,
                                                    mxArray * prhs[]);
static void mlfRecarga_2_3_StorageTexture_Callback(mxArray * hObject,
                                                   mxArray * eventdata,
                                                   mxArray * handles);
static void mlxRecarga_2_3_StorageTexture_Callback(int nlhs,
                                                   mxArray * plhs[],
                                                   int nrhs,
                                                   mxArray * prhs[]);
static void mlfRecarga_2_3_NativeTexture_CreateFcn(mxArray * hObject,
                                                   mxArray * eventdata,
                                                   mxArray * handles);
static void mlxRecarga_2_3_NativeTexture_CreateFcn(int nlhs,
                                                   mxArray * plhs[],
                                                   int nrhs,
                                                   mxArray * prhs[]);
static void mlfRecarga_2_3_NativeTexture_Callback(mxArray * hObject,
                                                  mxArray * eventdata,
                                                  mxArray * handles);
static void mlxRecarga_2_3_NativeTexture_Callback(int nlhs,
                                                  mxArray * plhs[],
                                                  int nrhs,
                                                  mxArray * prhs[]);
static void mlfRecarga_2_3_Kstore_CreateFcn(mxArray * hObject,
                                            mxArray * eventdata,
                                            mxArray * handles);
static void mlxRecarga_2_3_Kstore_CreateFcn(int nlhs,
                                            mxArray * plhs[],
                                            int nrhs,
                                            mxArray * prhs[]);
static void mlfRecarga_2_3_Kstore_Callback(mxArray * hObject,
                                           mxArray * eventdata,
                                           mxArray * handles);
static void mlxRecarga_2_3_Kstore_Callback(int nlhs,
                                           mxArray * plhs[],
                                           int nrhs,
                                           mxArray * prhs[]);
static void mlfRecarga_2_3_Kroot_CreateFcn(mxArray * hObject,
                                           mxArray * eventdata,
                                           mxArray * handles);
static void mlxRecarga_2_3_Kroot_CreateFcn(int nlhs,
                                           mxArray * plhs[],
                                           int nrhs,
                                           mxArray * prhs[]);
static void mlfRecarga_2_3_Kroot_Callback(mxArray * hObject,
                                          mxArray * eventdata,
                                          mxArray * handles);
static void mlxRecarga_2_3_Kroot_Callback(int nlhs,
                                          mxArray * plhs[],
                                          int nrhs,
                                          mxArray * prhs[]);
static void mlfRecarga_2_3_pushbutton3_Callback(mxArray * hObject,
                                                mxArray * eventdata,
                                                mxArray * handles);
static void mlxRecarga_2_3_pushbutton3_Callback(int nlhs,
                                                mxArray * plhs[],
                                                int nrhs,
                                                mxArray * prhs[]);
static void mlfRecarga_2_3_SMVol_CreateFcn(mxArray * hObject,
                                           mxArray * eventdata,
                                           mxArray * handles);
static void mlxRecarga_2_3_SMVol_CreateFcn(int nlhs,
                                           mxArray * plhs[],
                                           int nrhs,
                                           mxArray * prhs[]);
static void mlfRecarga_2_3_SMVol_Callback(mxArray * hObject,
                                          mxArray * eventdata,
                                          mxArray * handles);
static void mlxRecarga_2_3_SMVol_Callback(int nlhs,
                                          mxArray * plhs[],
                                          int nrhs,
                                          mxArray * prhs[]);
static void mlfRecarga_2_3_SMpercent_CreateFcn(mxArray * hObject,
                                               mxArray * eventdata,
                                               mxArray * handles);
static void mlxRecarga_2_3_SMpercent_CreateFcn(int nlhs,
                                               mxArray * plhs[],
                                               int nrhs,
                                               mxArray * prhs[]);
static void mlfRecarga_2_3_SMpercent_Callback(mxArray * hObject,
                                              mxArray * eventdata,
                                              mxArray * handles);
static void mlxRecarga_2_3_SMpercent_Callback(int nlhs,
                                              mxArray * plhs[],
                                              int nrhs,
                                              mxArray * prhs[]);
static void mlfRecarga_2_3_SMdepth_CreateFcn(mxArray * hObject,
                                             mxArray * eventdata,
                                             mxArray * handles);
static void mlxRecarga_2_3_SMdepth_CreateFcn(int nlhs,
                                             mxArray * plhs[],
                                             int nrhs,
                                             mxArray * prhs[]);
static void mlfRecarga_2_3_SMdepth_Callback(mxArray * hObject,
                                            mxArray * eventdata,
                                            mxArray * handles);
static void mlxRecarga_2_3_SMdepth_Callback(int nlhs,
                                            mxArray * plhs[],
                                            int nrhs,
                                            mxArray * prhs[]);
static void mlfRecarga_2_3_Untitled_1_Callback(mxArray * hObject,
                                               mxArray * eventdata,
                                               mxArray * handles);
static void mlxRecarga_2_3_Untitled_1_Callback(int nlhs,
                                               mxArray * plhs[],
                                               int nrhs,
                                               mxArray * prhs[]);
static void mlfRecarga_2_3_Untitled_2_Callback(mxArray * hObject,
                                               mxArray * eventdata,
                                               mxArray * handles);
static void mlxRecarga_2_3_Untitled_2_Callback(int nlhs,
                                               mxArray * plhs[],
                                               int nrhs,
                                               mxArray * prhs[]);
static void mlfRecarga_2_3_Stayper_CreateFcn(mxArray * hObject,
                                             mxArray * eventdata,
                                             mxArray * handles);
static void mlxRecarga_2_3_Stayper_CreateFcn(int nlhs,
                                             mxArray * plhs[],
                                             int nrhs,
                                             mxArray * prhs[]);
static void mlfRecarga_2_3_Stayper_Callback(mxArray * hObject,
                                            mxArray * eventdata,
                                            mxArray * handles);
static void mlxRecarga_2_3_Stayper_Callback(int nlhs,
                                            mxArray * plhs[],
                                            int nrhs,
                                            mxArray * prhs[]);
static void mlfRecarga_2_3_StayDpth_CreateFcn(mxArray * hObject,
                                              mxArray * eventdata,
                                              mxArray * handles);
static void mlxRecarga_2_3_StayDpth_CreateFcn(int nlhs,
                                              mxArray * plhs[],
                                              int nrhs,
                                              mxArray * prhs[]);
static void mlfRecarga_2_3_StayDpth_Callback(mxArray * hObject,
                                             mxArray * eventdata,
                                             mxArray * handles);
static void mlxRecarga_2_3_StayDpth_Callback(int nlhs,
                                             mxArray * plhs[],
                                             int nrhs,
                                             mxArray * prhs[]);
static void mlfRecarga_2_3_Summary_Callback(mxArray * hObject,
                                            mxArray * eventdata,
                                            mxArray * handles);
static void mlxRecarga_2_3_Summary_Callback(int nlhs,
                                            mxArray * plhs[],
                                            int nrhs,
                                            mxArray * prhs[]);
static void mlfRecarga_2_3_Record_Callback(mxArray * hObject,
                                           mxArray * eventdata,
                                           mxArray * handles);
static void mlxRecarga_2_3_Record_Callback(int nlhs,
                                           mxArray * plhs[],
                                           int nrhs,
                                           mxArray * prhs[]);
static void mlfRecarga_2_3_edit67_CreateFcn(mxArray * hObject,
                                            mxArray * eventdata,
                                            mxArray * handles);
static void mlxRecarga_2_3_edit67_CreateFcn(int nlhs,
                                            mxArray * plhs[],
                                            int nrhs,
                                            mxArray * prhs[]);
static void mlfRecarga_2_3_edit67_Callback(mxArray * hObject,
                                           mxArray * eventdata,
                                           mxArray * handles);
static void mlxRecarga_2_3_edit67_Callback(int nlhs,
                                           mxArray * plhs[],
                                           int nrhs,
                                           mxArray * prhs[]);
static void mlfRecarga_2_3_precip_CreateFcn(mxArray * hObject,
                                            mxArray * eventdata,
                                            mxArray * handles);
static void mlxRecarga_2_3_precip_CreateFcn(int nlhs,
                                            mxArray * plhs[],
                                            int nrhs,
                                            mxArray * prhs[]);
static void mlfRecarga_2_3_precip_Callback(mxArray * hObject,
                                           mxArray * eventdata,
                                           mxArray * handles);
static void mlxRecarga_2_3_precip_Callback(int nlhs,
                                           mxArray * plhs[],
                                           int nrhs,
                                           mxArray * prhs[]);
static void mlfRecarga_2_3_SimType_CreateFcn(mxArray * hObject,
                                             mxArray * eventdata,
                                             mxArray * handles);
static void mlxRecarga_2_3_SimType_CreateFcn(int nlhs,
                                             mxArray * plhs[],
                                             int nrhs,
                                             mxArray * prhs[]);
static void mlfRecarga_2_3_SimType_Callback(mxArray * hObject,
                                            mxArray * eventdata,
                                            mxArray * handles);
static void mlxRecarga_2_3_SimType_Callback(int nlhs,
                                            mxArray * plhs[],
                                            int nrhs,
                                            mxArray * prhs[]);
static void mlfRecarga_2_3_PptType_CreateFcn(mxArray * hObject,
                                             mxArray * eventdata,
                                             mxArray * handles);
static void mlxRecarga_2_3_PptType_CreateFcn(int nlhs,
                                             mxArray * plhs[],
                                             int nrhs,
                                             mxArray * prhs[]);
static void mlfRecarga_2_3_PptType_Callback(mxArray * hObject,
                                            mxArray * eventdata,
                                            mxArray * handles);
static void mlxRecarga_2_3_PptType_Callback(int nlhs,
                                            mxArray * plhs[],
                                            int nrhs,
                                            mxArray * prhs[]);
static void mlfRecarga_2_3_PptDepth_CreateFcn(mxArray * hObject,
                                              mxArray * eventdata,
                                              mxArray * handles);
static void mlxRecarga_2_3_PptDepth_CreateFcn(int nlhs,
                                              mxArray * plhs[],
                                              int nrhs,
                                              mxArray * prhs[]);
static void mlfRecarga_2_3_PptDepth_Callback(mxArray * hObject,
                                             mxArray * eventdata,
                                             mxArray * handles);
static void mlxRecarga_2_3_PptDepth_Callback(int nlhs,
                                             mxArray * plhs[],
                                             int nrhs,
                                             mxArray * prhs[]);
static void mlfRecarga_2_3_Units_CreateFcn(mxArray * hObject,
                                           mxArray * eventdata,
                                           mxArray * handles);
static void mlxRecarga_2_3_Units_CreateFcn(int nlhs,
                                           mxArray * plhs[],
                                           int nrhs,
                                           mxArray * prhs[]);
static void mlfRecarga_2_3_Units_Callback(mxArray * hObject,
                                          mxArray * eventdata,
                                          mxArray * handles);
static void mlxRecarga_2_3_Units_Callback(int nlhs,
                                          mxArray * plhs[],
                                          int nrhs,
                                          mxArray * prhs[]);
static void mlfRecarga_2_3_CurrentUnit_CreateFcn(mxArray * hObject,
                                                 mxArray * eventdata,
                                                 mxArray * handles);
static void mlxRecarga_2_3_CurrentUnit_CreateFcn(int nlhs,
                                                 mxArray * plhs[],
                                                 int nrhs,
                                                 mxArray * prhs[]);
static void mlfRecarga_2_3_CurrentUnit_Callback(mxArray * hObject,
                                                mxArray * eventdata,
                                                mxArray * handles);
static void mlxRecarga_2_3_CurrentUnit_Callback(int nlhs,
                                                mxArray * plhs[],
                                                int nrhs,
                                                mxArray * prhs[]);
static void mlfRecarga_2_3_Far_Callback(mxArray * hObject,
                                        mxArray * eventdata,
                                        mxArray * handles);
static void mlxRecarga_2_3_Far_Callback(int nlhs,
                                        mxArray * plhs[],
                                        int nrhs,
                                        mxArray * prhs[]);
static void mlfRecarga_2_3_target_stayon_CreateFcn(mxArray * hObject,
                                                   mxArray * eventdata,
                                                   mxArray * handles);
static void mlxRecarga_2_3_target_stayon_CreateFcn(int nlhs,
                                                   mxArray * plhs[],
                                                   int nrhs,
                                                   mxArray * prhs[]);
static void mlfRecarga_2_3_target_stayon_Callback(mxArray * hObject,
                                                  mxArray * eventdata,
                                                  mxArray * handles);
static void mlxRecarga_2_3_target_stayon_Callback(int nlhs,
                                                  mxArray * plhs[],
                                                  int nrhs,
                                                  mxArray * prhs[]);
static void mlfRecarga_2_3_Estimate_FAR_CreateFcn(mxArray * hObject,
                                                  mxArray * eventdata,
                                                  mxArray * handles);
static void mlxRecarga_2_3_Estimate_FAR_CreateFcn(int nlhs,
                                                  mxArray * plhs[],
                                                  int nrhs,
                                                  mxArray * prhs[]);
static void mlfRecarga_2_3_Estimate_FAR_Callback(mxArray * hObject,
                                                 mxArray * eventdata,
                                                 mxArray * handles);
static void mlxRecarga_2_3_Estimate_FAR_Callback(int nlhs,
                                                 mxArray * plhs[],
                                                 int nrhs,
                                                 mxArray * prhs[]);
static void mlfRecarga_2_3_axes5_CreateFcn(mxArray * hObject,
                                           mxArray * eventdata,
                                           mxArray * handles);
static void mlxRecarga_2_3_axes5_CreateFcn(int nlhs,
                                           mxArray * plhs[],
                                           int nrhs,
                                           mxArray * prhs[]);
static void mlfRecarga_2_3_axes9_CreateFcn(mxArray * hObject,
                                           mxArray * eventdata,
                                           mxArray * handles);
static void mlxRecarga_2_3_axes9_CreateFcn(int nlhs,
                                           mxArray * plhs[],
                                           int nrhs,
                                           mxArray * prhs[]);
static mxArray * Mrecarga_2_3(int nargout_, mxArray * varargin);
static void Mrecarga_2_3_RECARGA_2_3_OpeningFcn(mxArray * hObject,
                                                mxArray * eventdata,
                                                mxArray * handles,
                                                mxArray * varargin);
static mxArray * Mrecarga_2_3_RECARGA_2_3_OutputFcn(int nargout_,
                                                    mxArray * hObject,
                                                    mxArray * eventdata,
                                                    mxArray * handles);
static void Mrecarga_2_3_Process_Callback(mxArray * hObject,
                                          mxArray * eventdata,
                                          mxArray * handles);
static void Mrecarga_2_3_Progress_CreateFcn(mxArray * hObject,
                                            mxArray * eventdata,
                                            mxArray * handles);
static void Mrecarga_2_3_Progress_Callback(mxArray * hObject,
                                           mxArray * eventdata,
                                           mxArray * handles);
static void Mrecarga_2_3_Runon_CreateFcn(mxArray * hObject,
                                         mxArray * eventdata,
                                         mxArray * handles);
static void Mrecarga_2_3_Runon_Callback(mxArray * hObject,
                                        mxArray * eventdata,
                                        mxArray * handles);
static void Mrecarga_2_3_Runoff_CreateFcn(mxArray * hObject,
                                          mxArray * eventdata,
                                          mxArray * handles);
static void Mrecarga_2_3_Runoff_Callback(mxArray * hObject,
                                         mxArray * eventdata,
                                         mxArray * handles);
static void Mrecarga_2_3_Recharge_CreateFcn(mxArray * hObject,
                                            mxArray * eventdata,
                                            mxArray * handles);
static void Mrecarga_2_3_Recharge_Callback(mxArray * hObject,
                                           mxArray * eventdata,
                                           mxArray * handles);
static void Mrecarga_2_3_Evap_CreateFcn(mxArray * hObject,
                                        mxArray * eventdata,
                                        mxArray * handles);
static void Mrecarga_2_3_Evap_Callback(mxArray * hObject,
                                       mxArray * eventdata,
                                       mxArray * handles);
static void Mrecarga_2_3_Storage_CreateFcn(mxArray * hObject,
                                           mxArray * eventdata,
                                           mxArray * handles);
static void Mrecarga_2_3_Storage_Callback(mxArray * hObject,
                                          mxArray * eventdata,
                                          mxArray * handles);
static void Mrecarga_2_3_Prunon_CreateFcn(mxArray * hObject,
                                          mxArray * eventdata,
                                          mxArray * handles);
static void Mrecarga_2_3_Prunon_Callback(mxArray * hObject,
                                         mxArray * eventdata,
                                         mxArray * handles);
static void Mrecarga_2_3_Prunoff_CreateFcn(mxArray * hObject,
                                           mxArray * eventdata,
                                           mxArray * handles);
static void Mrecarga_2_3_Prunoff_Callback(mxArray * hObject,
                                          mxArray * eventdata,
                                          mxArray * handles);
static void Mrecarga_2_3_Precharge_CreateFcn(mxArray * hObject,
                                             mxArray * eventdata,
                                             mxArray * handles);
static void Mrecarga_2_3_Precharge_Callback(mxArray * hObject,
                                            mxArray * eventdata,
                                            mxArray * handles);
static void Mrecarga_2_3_Pevap_CreateFcn(mxArray * hObject,
                                         mxArray * eventdata,
                                         mxArray * handles);
static void Mrecarga_2_3_Pevap_Callback(mxArray * hObject,
                                        mxArray * eventdata,
                                        mxArray * handles);
static void Mrecarga_2_3_maxpond_CreateFcn(mxArray * hObject,
                                           mxArray * eventdata,
                                           mxArray * handles);
static void Mrecarga_2_3_maxpond_Callback(mxArray * hObject,
                                          mxArray * eventdata,
                                          mxArray * handles);
static void Mrecarga_2_3_maxwilt_CreateFcn(mxArray * hObject,
                                           mxArray * eventdata,
                                           mxArray * handles);
static void Mrecarga_2_3_maxwilt_Callback(mxArray * hObject,
                                          mxArray * eventdata,
                                          mxArray * handles);
static void Mrecarga_2_3_tpond_CreateFcn(mxArray * hObject,
                                         mxArray * eventdata,
                                         mxArray * handles);
static void Mrecarga_2_3_tpond_Callback(mxArray * hObject,
                                        mxArray * eventdata,
                                        mxArray * handles);
static void Mrecarga_2_3_OFtimes_CreateFcn(mxArray * hObject,
                                           mxArray * eventdata,
                                           mxArray * handles);
static void Mrecarga_2_3_OFtimes_Callback(mxArray * hObject,
                                          mxArray * eventdata,
                                          mxArray * handles);
static void Mrecarga_2_3_ImpA_CreateFcn(mxArray * hObject,
                                        mxArray * eventdata,
                                        mxArray * handles);
static void Mrecarga_2_3_ImpA_Callback(mxArray * hObject,
                                       mxArray * eventdata,
                                       mxArray * handles);
static void Mrecarga_2_3_CN_CreateFcn(mxArray * hObject,
                                      mxArray * eventdata,
                                      mxArray * handles);
static void Mrecarga_2_3_CN_Callback(mxArray * hObject,
                                     mxArray * eventdata,
                                     mxArray * handles);
static void Mrecarga_2_3_ImpVol_CreateFcn(mxArray * hObject,
                                          mxArray * eventdata,
                                          mxArray * handles);
static void Mrecarga_2_3_ImpVol_Callback(mxArray * hObject,
                                         mxArray * eventdata,
                                         mxArray * handles);
static void Mrecarga_2_3_PervVol_CreateFcn(mxArray * hObject,
                                           mxArray * eventdata,
                                           mxArray * handles);
static void Mrecarga_2_3_PervVol_Callback(mxArray * hObject,
                                          mxArray * eventdata,
                                          mxArray * handles);
static void Mrecarga_2_3_ImpDpth_CreateFcn(mxArray * hObject,
                                           mxArray * eventdata,
                                           mxArray * handles);
static void Mrecarga_2_3_ImpDpth_Callback(mxArray * hObject,
                                          mxArray * eventdata,
                                          mxArray * handles);
static void Mrecarga_2_3_PervDpth_CreateFcn(mxArray * hObject,
                                            mxArray * eventdata,
                                            mxArray * handles);
static void Mrecarga_2_3_PervDpth_Callback(mxArray * hObject,
                                           mxArray * eventdata,
                                           mxArray * handles);
static void Mrecarga_2_3_RoffDpth_CreateFcn(mxArray * hObject,
                                            mxArray * eventdata,
                                            mxArray * handles);
static void Mrecarga_2_3_RoffDpth_Callback(mxArray * hObject,
                                           mxArray * eventdata,
                                           mxArray * handles);
static void Mrecarga_2_3_RchrgDpth_CreateFcn(mxArray * hObject,
                                             mxArray * eventdata,
                                             mxArray * handles);
static void Mrecarga_2_3_RchrgDpth_Callback(mxArray * hObject,
                                            mxArray * eventdata,
                                            mxArray * handles);
static void Mrecarga_2_3_EvapDpth_CreateFcn(mxArray * hObject,
                                            mxArray * eventdata,
                                            mxArray * handles);
static void Mrecarga_2_3_EvapDpth_Callback(mxArray * hObject,
                                           mxArray * eventdata,
                                           mxArray * handles);
static void Mrecarga_2_3_RnOnDpth_CreateFcn(mxArray * hObject,
                                            mxArray * eventdata,
                                            mxArray * handles);
static void Mrecarga_2_3_RnOnDpth_Callback(mxArray * hObject,
                                           mxArray * eventdata,
                                           mxArray * handles);
static void Mrecarga_2_3_UdVol_CreateFcn(mxArray * hObject,
                                         mxArray * eventdata,
                                         mxArray * handles);
static void Mrecarga_2_3_UdVol_Callback(mxArray * hObject,
                                        mxArray * eventdata,
                                        mxArray * handles);
static void Mrecarga_2_3_UdFrac_CreateFcn(mxArray * hObject,
                                          mxArray * eventdata,
                                          mxArray * handles);
static void Mrecarga_2_3_UdFrac_Callback(mxArray * hObject,
                                         mxArray * eventdata,
                                         mxArray * handles);
static void Mrecarga_2_3_UdDpth_CreateFcn(mxArray * hObject,
                                          mxArray * eventdata,
                                          mxArray * handles);
static void Mrecarga_2_3_UdDpth_Callback(mxArray * hObject,
                                         mxArray * eventdata,
                                         mxArray * handles);
static void Mrecarga_2_3_UFlow_CreateFcn(mxArray * hObject,
                                         mxArray * eventdata,
                                         mxArray * handles);
static void Mrecarga_2_3_UFlow_Callback(mxArray * hObject,
                                        mxArray * eventdata,
                                        mxArray * handles);
static void Mrecarga_2_3_BasinArea_CreateFcn(mxArray * hObject,
                                             mxArray * eventdata,
                                             mxArray * handles);
static void Mrecarga_2_3_BasinArea_Callback(mxArray * hObject,
                                            mxArray * eventdata,
                                            mxArray * handles);
static void Mrecarga_2_3_Udiam_CreateFcn(mxArray * hObject,
                                         mxArray * eventdata,
                                         mxArray * handles);
static void Mrecarga_2_3_Udiam_Callback(mxArray * hObject,
                                        mxArray * eventdata,
                                        mxArray * handles);
static void Mrecarga_2_3_AveET_CreateFcn(mxArray * hObject,
                                         mxArray * eventdata,
                                         mxArray * handles);
static void Mrecarga_2_3_AveET_Callback(mxArray * hObject,
                                        mxArray * eventdata,
                                        mxArray * handles);
static void Mrecarga_2_3_Sd_CreateFcn(mxArray * hObject,
                                      mxArray * eventdata,
                                      mxArray * handles);
static void Mrecarga_2_3_Sd_Callback(mxArray * hObject,
                                     mxArray * eventdata,
                                     mxArray * handles);
static void Mrecarga_2_3_Srz_CreateFcn(mxArray * hObject,
                                       mxArray * eventdata,
                                       mxArray * handles);
static void Mrecarga_2_3_Srz_Callback(mxArray * hObject,
                                      mxArray * eventdata,
                                      mxArray * handles);
static void Mrecarga_2_3_St_CreateFcn(mxArray * hObject,
                                      mxArray * eventdata,
                                      mxArray * handles);
static void Mrecarga_2_3_St_Callback(mxArray * hObject,
                                     mxArray * eventdata,
                                     mxArray * handles);
static void Mrecarga_2_3_Ksat_CreateFcn(mxArray * hObject,
                                        mxArray * eventdata,
                                        mxArray * handles);
static void Mrecarga_2_3_Ksat_Callback(mxArray * hObject,
                                       mxArray * eventdata,
                                       mxArray * handles);
static void Mrecarga_2_3_Input_CreateFcn(mxArray * hObject,
                                         mxArray * eventdata,
                                         mxArray * handles);
static void Mrecarga_2_3_Input_Callback(mxArray * hObject,
                                        mxArray * eventdata,
                                        mxArray * handles);
static void Mrecarga_2_3_edit9_CreateFcn(mxArray * hObject,
                                         mxArray * eventdata,
                                         mxArray * handles);
static void Mrecarga_2_3_edit9_Callback(mxArray * hObject,
                                        mxArray * eventdata,
                                        mxArray * handles);
static void Mrecarga_2_3_popupmenu1_CreateFcn(mxArray * hObject,
                                              mxArray * eventdata,
                                              mxArray * handles);
static void Mrecarga_2_3_popupmenu1_Callback(mxArray * hObject,
                                             mxArray * eventdata,
                                             mxArray * handles);
static void Mrecarga_2_3_Length_CreateFcn(mxArray * hObject,
                                          mxArray * eventdata,
                                          mxArray * handles);
static void Mrecarga_2_3_Length_Callback(mxArray * hObject,
                                         mxArray * eventdata,
                                         mxArray * handles);
static void Mrecarga_2_3_Output_CreateFcn(mxArray * hObject,
                                          mxArray * eventdata,
                                          mxArray * handles);
static void Mrecarga_2_3_Output_Callback(mxArray * hObject,
                                         mxArray * eventdata,
                                         mxArray * handles);
static void Mrecarga_2_3_Name_CreateFcn(mxArray * hObject,
                                        mxArray * eventdata,
                                        mxArray * handles);
static void Mrecarga_2_3_Name_Callback(mxArray * hObject,
                                       mxArray * eventdata,
                                       mxArray * handles);
static void Mrecarga_2_3_RGArea_CreateFcn(mxArray * hObject,
                                          mxArray * eventdata,
                                          mxArray * handles);
static void Mrecarga_2_3_RGArea_Callback(mxArray * hObject,
                                         mxArray * eventdata,
                                         mxArray * handles);
static void Mrecarga_2_3_RGCalc_Callback(mxArray * hObject,
                                         mxArray * eventdata,
                                         mxArray * handles);
static void Mrecarga_2_3_Process_CreateFcn(mxArray * hObject,
                                           mxArray * eventdata,
                                           mxArray * handles);
static void Mrecarga_2_3_clear_Callback(mxArray * hObject,
                                        mxArray * eventdata,
                                        mxArray * handles);
static void Mrecarga_2_3_RootTexture_CreateFcn(mxArray * hObject,
                                               mxArray * eventdata,
                                               mxArray * handles);
static void Mrecarga_2_3_RootTexture_Callback(mxArray * hObject,
                                              mxArray * eventdata,
                                              mxArray * handles);
static void Mrecarga_2_3_StorageTexture_CreateFcn(mxArray * hObject,
                                                  mxArray * eventdata,
                                                  mxArray * handles);
static void Mrecarga_2_3_StorageTexture_Callback(mxArray * hObject,
                                                 mxArray * eventdata,
                                                 mxArray * handles);
static void Mrecarga_2_3_NativeTexture_CreateFcn(mxArray * hObject,
                                                 mxArray * eventdata,
                                                 mxArray * handles);
static void Mrecarga_2_3_NativeTexture_Callback(mxArray * hObject,
                                                mxArray * eventdata,
                                                mxArray * handles);
static void Mrecarga_2_3_Kstore_CreateFcn(mxArray * hObject,
                                          mxArray * eventdata,
                                          mxArray * handles);
static void Mrecarga_2_3_Kstore_Callback(mxArray * hObject,
                                         mxArray * eventdata,
                                         mxArray * handles);
static void Mrecarga_2_3_Kroot_CreateFcn(mxArray * hObject,
                                         mxArray * eventdata,
                                         mxArray * handles);
static void Mrecarga_2_3_Kroot_Callback(mxArray * hObject,
                                        mxArray * eventdata,
                                        mxArray * handles);
static void Mrecarga_2_3_pushbutton3_Callback(mxArray * hObject,
                                              mxArray * eventdata,
                                              mxArray * handles);
static void Mrecarga_2_3_SMVol_CreateFcn(mxArray * hObject,
                                         mxArray * eventdata,
                                         mxArray * handles);
static void Mrecarga_2_3_SMVol_Callback(mxArray * hObject,
                                        mxArray * eventdata,
                                        mxArray * handles);
static void Mrecarga_2_3_SMpercent_CreateFcn(mxArray * hObject,
                                             mxArray * eventdata,
                                             mxArray * handles);
static void Mrecarga_2_3_SMpercent_Callback(mxArray * hObject,
                                            mxArray * eventdata,
                                            mxArray * handles);
static void Mrecarga_2_3_SMdepth_CreateFcn(mxArray * hObject,
                                           mxArray * eventdata,
                                           mxArray * handles);
static void Mrecarga_2_3_SMdepth_Callback(mxArray * hObject,
                                          mxArray * eventdata,
                                          mxArray * handles);
static void Mrecarga_2_3_Untitled_1_Callback(mxArray * hObject,
                                             mxArray * eventdata,
                                             mxArray * handles);
static void Mrecarga_2_3_Untitled_2_Callback(mxArray * hObject,
                                             mxArray * eventdata,
                                             mxArray * handles);
static void Mrecarga_2_3_Stayper_CreateFcn(mxArray * hObject,
                                           mxArray * eventdata,
                                           mxArray * handles);
static void Mrecarga_2_3_Stayper_Callback(mxArray * hObject,
                                          mxArray * eventdata,
                                          mxArray * handles);
static void Mrecarga_2_3_StayDpth_CreateFcn(mxArray * hObject,
                                            mxArray * eventdata,
                                            mxArray * handles);
static void Mrecarga_2_3_StayDpth_Callback(mxArray * hObject,
                                           mxArray * eventdata,
                                           mxArray * handles);
static void Mrecarga_2_3_Summary_Callback(mxArray * hObject,
                                          mxArray * eventdata,
                                          mxArray * handles);
static void Mrecarga_2_3_Record_Callback(mxArray * hObject,
                                         mxArray * eventdata,
                                         mxArray * handles);
static void Mrecarga_2_3_edit67_CreateFcn(mxArray * hObject,
                                          mxArray * eventdata,
                                          mxArray * handles);
static void Mrecarga_2_3_edit67_Callback(mxArray * hObject,
                                         mxArray * eventdata,
                                         mxArray * handles);
static void Mrecarga_2_3_precip_CreateFcn(mxArray * hObject,
                                          mxArray * eventdata,
                                          mxArray * handles);
static void Mrecarga_2_3_precip_Callback(mxArray * hObject,
                                         mxArray * eventdata,
                                         mxArray * handles);
static void Mrecarga_2_3_SimType_CreateFcn(mxArray * hObject,
                                           mxArray * eventdata,
                                           mxArray * handles);
static void Mrecarga_2_3_SimType_Callback(mxArray * hObject,
                                          mxArray * eventdata,
                                          mxArray * handles);
static void Mrecarga_2_3_PptType_CreateFcn(mxArray * hObject,
                                           mxArray * eventdata,
                                           mxArray * handles);
static void Mrecarga_2_3_PptType_Callback(mxArray * hObject,
                                          mxArray * eventdata,
                                          mxArray * handles);
static void Mrecarga_2_3_PptDepth_CreateFcn(mxArray * hObject,
                                            mxArray * eventdata,
                                            mxArray * handles);
static void Mrecarga_2_3_PptDepth_Callback(mxArray * hObject,
                                           mxArray * eventdata,
                                           mxArray * handles);
static void Mrecarga_2_3_Units_CreateFcn(mxArray * hObject,
                                         mxArray * eventdata,
                                         mxArray * handles);
static void Mrecarga_2_3_Units_Callback(mxArray * hObject,
                                        mxArray * eventdata,
                                        mxArray * handles);
static void Mrecarga_2_3_CurrentUnit_CreateFcn(mxArray * hObject,
                                               mxArray * eventdata,
                                               mxArray * handles);
static void Mrecarga_2_3_CurrentUnit_Callback(mxArray * hObject,
                                              mxArray * eventdata,
                                              mxArray * handles);
static void Mrecarga_2_3_Far_Callback(mxArray * hObject,
                                      mxArray * eventdata,
                                      mxArray * handles);
static void Mrecarga_2_3_target_stayon_CreateFcn(mxArray * hObject,
                                                 mxArray * eventdata,
                                                 mxArray * handles);
static void Mrecarga_2_3_target_stayon_Callback(mxArray * hObject,
                                                mxArray * eventdata,
                                                mxArray * handles);
static void Mrecarga_2_3_Estimate_FAR_CreateFcn(mxArray * hObject,
                                                mxArray * eventdata,
                                                mxArray * handles);
static void Mrecarga_2_3_Estimate_FAR_Callback(mxArray * hObject,
                                               mxArray * eventdata,
                                               mxArray * handles);
static void Mrecarga_2_3_axes5_CreateFcn(mxArray * hObject,
                                         mxArray * eventdata,
                                         mxArray * handles);
static void Mrecarga_2_3_axes9_CreateFcn(mxArray * hObject,
                                         mxArray * eventdata,
                                         mxArray * handles);

static mexFunctionTableEntry local_function_table_[136]
  = { { "RECARGA_2_3_OpeningFcn",
        mlxRecarga_2_3_RECARGA_2_3_OpeningFcn, -4, 0, NULL },
      { "RECARGA_2_3_OutputFcn",
        mlxRecarga_2_3_RECARGA_2_3_OutputFcn, 3, -1, NULL },
      { "Process_Callback", mlxRecarga_2_3_Process_Callback, 3, 0, NULL },
      { "Progress_CreateFcn", mlxRecarga_2_3_Progress_CreateFcn, 3, 0, NULL },
      { "Progress_Callback", mlxRecarga_2_3_Progress_Callback, 3, 0, NULL },
      { "Runon_CreateFcn", mlxRecarga_2_3_Runon_CreateFcn, 3, 0, NULL },
      { "Runon_Callback", mlxRecarga_2_3_Runon_Callback, 3, 0, NULL },
      { "Runoff_CreateFcn", mlxRecarga_2_3_Runoff_CreateFcn, 3, 0, NULL },
      { "Runoff_Callback", mlxRecarga_2_3_Runoff_Callback, 3, 0, NULL },
      { "Recharge_CreateFcn", mlxRecarga_2_3_Recharge_CreateFcn, 3, 0, NULL },
      { "Recharge_Callback", mlxRecarga_2_3_Recharge_Callback, 3, 0, NULL },
      { "Evap_CreateFcn", mlxRecarga_2_3_Evap_CreateFcn, 3, 0, NULL },
      { "Evap_Callback", mlxRecarga_2_3_Evap_Callback, 3, 0, NULL },
      { "Storage_CreateFcn", mlxRecarga_2_3_Storage_CreateFcn, 3, 0, NULL },
      { "Storage_Callback", mlxRecarga_2_3_Storage_Callback, 3, 0, NULL },
      { "Prunon_CreateFcn", mlxRecarga_2_3_Prunon_CreateFcn, 3, 0, NULL },
      { "Prunon_Callback", mlxRecarga_2_3_Prunon_Callback, 3, 0, NULL },
      { "Prunoff_CreateFcn", mlxRecarga_2_3_Prunoff_CreateFcn, 3, 0, NULL },
      { "Prunoff_Callback", mlxRecarga_2_3_Prunoff_Callback, 3, 0, NULL },
      { "Precharge_CreateFcn",
        mlxRecarga_2_3_Precharge_CreateFcn, 3, 0, NULL },
      { "Precharge_Callback", mlxRecarga_2_3_Precharge_Callback, 3, 0, NULL },
      { "Pevap_CreateFcn", mlxRecarga_2_3_Pevap_CreateFcn, 3, 0, NULL },
      { "Pevap_Callback", mlxRecarga_2_3_Pevap_Callback, 3, 0, NULL },
      { "maxpond_CreateFcn", mlxRecarga_2_3_maxpond_CreateFcn, 3, 0, NULL },
      { "maxpond_Callback", mlxRecarga_2_3_maxpond_Callback, 3, 0, NULL },
      { "maxwilt_CreateFcn", mlxRecarga_2_3_maxwilt_CreateFcn, 3, 0, NULL },
      { "maxwilt_Callback", mlxRecarga_2_3_maxwilt_Callback, 3, 0, NULL },
      { "tpond_CreateFcn", mlxRecarga_2_3_tpond_CreateFcn, 3, 0, NULL },
      { "tpond_Callback", mlxRecarga_2_3_tpond_Callback, 3, 0, NULL },
      { "OFtimes_CreateFcn", mlxRecarga_2_3_OFtimes_CreateFcn, 3, 0, NULL },
      { "OFtimes_Callback", mlxRecarga_2_3_OFtimes_Callback, 3, 0, NULL },
      { "ImpA_CreateFcn", mlxRecarga_2_3_ImpA_CreateFcn, 3, 0, NULL },
      { "ImpA_Callback", mlxRecarga_2_3_ImpA_Callback, 3, 0, NULL },
      { "CN_CreateFcn", mlxRecarga_2_3_CN_CreateFcn, 3, 0, NULL },
      { "CN_Callback", mlxRecarga_2_3_CN_Callback, 3, 0, NULL },
      { "ImpVol_CreateFcn", mlxRecarga_2_3_ImpVol_CreateFcn, 3, 0, NULL },
      { "ImpVol_Callback", mlxRecarga_2_3_ImpVol_Callback, 3, 0, NULL },
      { "PervVol_CreateFcn", mlxRecarga_2_3_PervVol_CreateFcn, 3, 0, NULL },
      { "PervVol_Callback", mlxRecarga_2_3_PervVol_Callback, 3, 0, NULL },
      { "ImpDpth_CreateFcn", mlxRecarga_2_3_ImpDpth_CreateFcn, 3, 0, NULL },
      { "ImpDpth_Callback", mlxRecarga_2_3_ImpDpth_Callback, 3, 0, NULL },
      { "PervDpth_CreateFcn", mlxRecarga_2_3_PervDpth_CreateFcn, 3, 0, NULL },
      { "PervDpth_Callback", mlxRecarga_2_3_PervDpth_Callback, 3, 0, NULL },
      { "RoffDpth_CreateFcn", mlxRecarga_2_3_RoffDpth_CreateFcn, 3, 0, NULL },
      { "RoffDpth_Callback", mlxRecarga_2_3_RoffDpth_Callback, 3, 0, NULL },
      { "RchrgDpth_CreateFcn",
        mlxRecarga_2_3_RchrgDpth_CreateFcn, 3, 0, NULL },
      { "RchrgDpth_Callback", mlxRecarga_2_3_RchrgDpth_Callback, 3, 0, NULL },
      { "EvapDpth_CreateFcn", mlxRecarga_2_3_EvapDpth_CreateFcn, 3, 0, NULL },
      { "EvapDpth_Callback", mlxRecarga_2_3_EvapDpth_Callback, 3, 0, NULL },
      { "RnOnDpth_CreateFcn", mlxRecarga_2_3_RnOnDpth_CreateFcn, 3, 0, NULL },
      { "RnOnDpth_Callback", mlxRecarga_2_3_RnOnDpth_Callback, 3, 0, NULL },
      { "UdVol_CreateFcn", mlxRecarga_2_3_UdVol_CreateFcn, 3, 0, NULL },
      { "UdVol_Callback", mlxRecarga_2_3_UdVol_Callback, 3, 0, NULL },
      { "UdFrac_CreateFcn", mlxRecarga_2_3_UdFrac_CreateFcn, 3, 0, NULL },
      { "UdFrac_Callback", mlxRecarga_2_3_UdFrac_Callback, 3, 0, NULL },
      { "UdDpth_CreateFcn", mlxRecarga_2_3_UdDpth_CreateFcn, 3, 0, NULL },
      { "UdDpth_Callback", mlxRecarga_2_3_UdDpth_Callback, 3, 0, NULL },
      { "UFlow_CreateFcn", mlxRecarga_2_3_UFlow_CreateFcn, 3, 0, NULL },
      { "UFlow_Callback", mlxRecarga_2_3_UFlow_Callback, 3, 0, NULL },
      { "BasinArea_CreateFcn",
        mlxRecarga_2_3_BasinArea_CreateFcn, 3, 0, NULL },
      { "BasinArea_Callback", mlxRecarga_2_3_BasinArea_Callback, 3, 0, NULL },
      { "Udiam_CreateFcn", mlxRecarga_2_3_Udiam_CreateFcn, 3, 0, NULL },
      { "Udiam_Callback", mlxRecarga_2_3_Udiam_Callback, 3, 0, NULL },
      { "AveET_CreateFcn", mlxRecarga_2_3_AveET_CreateFcn, 3, 0, NULL },
      { "AveET_Callback", mlxRecarga_2_3_AveET_Callback, 3, 0, NULL },
      { "Sd_CreateFcn", mlxRecarga_2_3_Sd_CreateFcn, 3, 0, NULL },
      { "Sd_Callback", mlxRecarga_2_3_Sd_Callback, 3, 0, NULL },
      { "Srz_CreateFcn", mlxRecarga_2_3_Srz_CreateFcn, 3, 0, NULL },
      { "Srz_Callback", mlxRecarga_2_3_Srz_Callback, 3, 0, NULL },
      { "St_CreateFcn", mlxRecarga_2_3_St_CreateFcn, 3, 0, NULL },
      { "St_Callback", mlxRecarga_2_3_St_Callback, 3, 0, NULL },
      { "Ksat_CreateFcn", mlxRecarga_2_3_Ksat_CreateFcn, 3, 0, NULL },
      { "Ksat_Callback", mlxRecarga_2_3_Ksat_Callback, 3, 0, NULL },
      { "Input_CreateFcn", mlxRecarga_2_3_Input_CreateFcn, 3, 0, NULL },
      { "Input_Callback", mlxRecarga_2_3_Input_Callback, 3, 0, NULL },
      { "edit9_CreateFcn", mlxRecarga_2_3_edit9_CreateFcn, 3, 0, NULL },
      { "edit9_Callback", mlxRecarga_2_3_edit9_Callback, 3, 0, NULL },
      { "popupmenu1_CreateFcn",
        mlxRecarga_2_3_popupmenu1_CreateFcn, 3, 0, NULL },
      { "popupmenu1_Callback",
        mlxRecarga_2_3_popupmenu1_Callback, 3, 0, NULL },
      { "Length_CreateFcn", mlxRecarga_2_3_Length_CreateFcn, 3, 0, NULL },
      { "Length_Callback", mlxRecarga_2_3_Length_Callback, 3, 0, NULL },
      { "Output_CreateFcn", mlxRecarga_2_3_Output_CreateFcn, 3, 0, NULL },
      { "Output_Callback", mlxRecarga_2_3_Output_Callback, 3, 0, NULL },
      { "Name_CreateFcn", mlxRecarga_2_3_Name_CreateFcn, 3, 0, NULL },
      { "Name_Callback", mlxRecarga_2_3_Name_Callback, 3, 0, NULL },
      { "RGArea_CreateFcn", mlxRecarga_2_3_RGArea_CreateFcn, 3, 0, NULL },
      { "RGArea_Callback", mlxRecarga_2_3_RGArea_Callback, 3, 0, NULL },
      { "RGCalc_Callback", mlxRecarga_2_3_RGCalc_Callback, 3, 0, NULL },
      { "Process_CreateFcn", mlxRecarga_2_3_Process_CreateFcn, 3, 0, NULL },
      { "clear_Callback", mlxRecarga_2_3_clear_Callback, 3, 0, NULL },
      { "RootTexture_CreateFcn",
        mlxRecarga_2_3_RootTexture_CreateFcn, 3, 0, NULL },
      { "RootTexture_Callback",
        mlxRecarga_2_3_RootTexture_Callback, 3, 0, NULL },
      { "StorageTexture_CreateFcn",
        mlxRecarga_2_3_StorageTexture_CreateFcn, 3, 0, NULL },
      { "StorageTexture_Callback",
        mlxRecarga_2_3_StorageTexture_Callback, 3, 0, NULL },
      { "NativeTexture_CreateFcn",
        mlxRecarga_2_3_NativeTexture_CreateFcn, 3, 0, NULL },
      { "NativeTexture_Callback",
        mlxRecarga_2_3_NativeTexture_Callback, 3, 0, NULL },
      { "Kstore_CreateFcn", mlxRecarga_2_3_Kstore_CreateFcn, 3, 0, NULL },
      { "Kstore_Callback", mlxRecarga_2_3_Kstore_Callback, 3, 0, NULL },
      { "Kroot_CreateFcn", mlxRecarga_2_3_Kroot_CreateFcn, 3, 0, NULL },
      { "Kroot_Callback", mlxRecarga_2_3_Kroot_Callback, 3, 0, NULL },
      { "pushbutton3_Callback",
        mlxRecarga_2_3_pushbutton3_Callback, 3, 0, NULL },
      { "SMVol_CreateFcn", mlxRecarga_2_3_SMVol_CreateFcn, 3, 0, NULL },
      { "SMVol_Callback", mlxRecarga_2_3_SMVol_Callback, 3, 0, NULL },
      { "SMpercent_CreateFcn",
        mlxRecarga_2_3_SMpercent_CreateFcn, 3, 0, NULL },
      { "SMpercent_Callback", mlxRecarga_2_3_SMpercent_Callback, 3, 0, NULL },
      { "SMdepth_CreateFcn", mlxRecarga_2_3_SMdepth_CreateFcn, 3, 0, NULL },
      { "SMdepth_Callback", mlxRecarga_2_3_SMdepth_Callback, 3, 0, NULL },
      { "Untitled_1_Callback",
        mlxRecarga_2_3_Untitled_1_Callback, 3, 0, NULL },
      { "Untitled_2_Callback",
        mlxRecarga_2_3_Untitled_2_Callback, 3, 0, NULL },
      { "Stayper_CreateFcn", mlxRecarga_2_3_Stayper_CreateFcn, 3, 0, NULL },
      { "Stayper_Callback", mlxRecarga_2_3_Stayper_Callback, 3, 0, NULL },
      { "StayDpth_CreateFcn", mlxRecarga_2_3_StayDpth_CreateFcn, 3, 0, NULL },
      { "StayDpth_Callback", mlxRecarga_2_3_StayDpth_Callback, 3, 0, NULL },
      { "Summary_Callback", mlxRecarga_2_3_Summary_Callback, 3, 0, NULL },
      { "Record_Callback", mlxRecarga_2_3_Record_Callback, 3, 0, NULL },
      { "edit67_CreateFcn", mlxRecarga_2_3_edit67_CreateFcn, 3, 0, NULL },
      { "edit67_Callback", mlxRecarga_2_3_edit67_Callback, 3, 0, NULL },
      { "precip_CreateFcn", mlxRecarga_2_3_precip_CreateFcn, 3, 0, NULL },
      { "precip_Callback", mlxRecarga_2_3_precip_Callback, 3, 0, NULL },
      { "SimType_CreateFcn", mlxRecarga_2_3_SimType_CreateFcn, 3, 0, NULL },
      { "SimType_Callback", mlxRecarga_2_3_SimType_Callback, 3, 0, NULL },
      { "PptType_CreateFcn", mlxRecarga_2_3_PptType_CreateFcn, 3, 0, NULL },
      { "PptType_Callback", mlxRecarga_2_3_PptType_Callback, 3, 0, NULL },
      { "PptDepth_CreateFcn", mlxRecarga_2_3_PptDepth_CreateFcn, 3, 0, NULL },
      { "PptDepth_Callback", mlxRecarga_2_3_PptDepth_Callback, 3, 0, NULL },
      { "Units_CreateFcn", mlxRecarga_2_3_Units_CreateFcn, 3, 0, NULL },
      { "Units_Callback", mlxRecarga_2_3_Units_Callback, 3, 0, NULL },
      { "CurrentUnit_CreateFcn",
        mlxRecarga_2_3_CurrentUnit_CreateFcn, 3, 0, NULL },
      { "CurrentUnit_Callback",
        mlxRecarga_2_3_CurrentUnit_Callback, 3, 0, NULL },
      { "Far_Callback", mlxRecarga_2_3_Far_Callback, 3, 0, NULL },
      { "target_stayon_CreateFcn",
        mlxRecarga_2_3_target_stayon_CreateFcn, 3, 0, NULL },
      { "target_stayon_Callback",
        mlxRecarga_2_3_target_stayon_Callback, 3, 0, NULL },
      { "Estimate_FAR_CreateFcn",
        mlxRecarga_2_3_Estimate_FAR_CreateFcn, 3, 0, NULL },
      { "Estimate_FAR_Callback",
        mlxRecarga_2_3_Estimate_FAR_Callback, 3, 0, NULL },
      { "axes5_CreateFcn", mlxRecarga_2_3_axes5_CreateFcn, 3, 0, NULL },
      { "axes9_CreateFcn", mlxRecarga_2_3_axes9_CreateFcn, 3, 0, NULL } };

_mexLocalFunctionTable _local_function_table_recarga_2_3
  = { 136, local_function_table_ };

/*
 * The function "mlfNRecarga_2_3" contains the nargout interface for the
 * "recarga_2_3" M-function from file "u:\final_recarga6\recarga\recarga_2_3.m"
 * (lines 1-48). This interface is only produced if the M-function uses the
 * special variable "nargout". The nargout interface allows the number of
 * requested outputs to be specified via the nargout argument, as opposed to
 * the normal interface which dynamically calculates the number of outputs
 * based on the number of non-NULL inputs it receives. This function processes
 * any input arguments and passes them to the implementation version of the
 * function, appearing above.
 */
mxArray * mlfNRecarga_2_3(int nargout, mlfVarargoutList * varargout, ...) {
    mxArray * varargin = NULL;
    mlfVarargin(&varargin, varargout, 0);
    mlfEnterNewContext(0, -1, varargin);
    nargout += mclNargout(varargout);
    *mlfGetVarargoutCellPtr(varargout) = Mrecarga_2_3(nargout, varargin);
    mlfRestorePreviousContext(0, 0);
    mxDestroyArray(varargin);
    return mlfAssignOutputs(varargout);
}

/*
 * The function "mlfRecarga_2_3" contains the normal interface for the
 * "recarga_2_3" M-function from file "u:\final_recarga6\recarga\recarga_2_3.m"
 * (lines 1-48). This function processes any input arguments and passes them to
 * the implementation version of the function, appearing above.
 */
mxArray * mlfRecarga_2_3(mlfVarargoutList * varargout, ...) {
    mxArray * varargin = NULL;
    int nargout = 0;
    mlfVarargin(&varargin, varargout, 0);
    mlfEnterNewContext(0, -1, varargin);
    nargout += mclNargout(varargout);
    *mlfGetVarargoutCellPtr(varargout) = Mrecarga_2_3(nargout, varargin);
    mlfRestorePreviousContext(0, 0);
    mxDestroyArray(varargin);
    return mlfAssignOutputs(varargout);
}

/*
 * The function "mlfVRecarga_2_3" contains the void interface for the
 * "recarga_2_3" M-function from file "u:\final_recarga6\recarga\recarga_2_3.m"
 * (lines 1-48). The void interface is only produced if the M-function uses the
 * special variable "nargout", and has at least one output. The void interface
 * function specifies zero output arguments to the implementation version of
 * the function, and in the event that the implementation version still returns
 * an output (which, in MATLAB, would be assigned to the "ans" variable), it
 * deallocates the output. This function processes any input arguments and
 * passes them to the implementation version of the function, appearing above.
 */
void mlfVRecarga_2_3(mxArray * synthetic_varargin_argument, ...) {
    mxArray * varargin = NULL;
    mxArray * varargout = NULL;
    mlfVarargin(&varargin, synthetic_varargin_argument, 1);
    mlfEnterNewContext(0, -1, varargin);
    varargout = Mrecarga_2_3(0, synthetic_varargin_argument);
    mlfRestorePreviousContext(0, 0);
    mxDestroyArray(varargin);
}

/*
 * The function "mlxRecarga_2_3" contains the feval interface for the
 * "recarga_2_3" M-function from file "u:\final_recarga6\recarga\recarga_2_3.m"
 * (lines 1-48). The feval function calls the implementation version of
 * recarga_2_3 through this function. This function processes any input
 * arguments and passes them to the implementation version of the function,
 * appearing above.
 */
void mlxRecarga_2_3(int nlhs, mxArray * plhs[], int nrhs, mxArray * prhs[]) {
    mxArray * mprhs[1];
    mxArray * mplhs[1];
    int i;
    for (i = 0; i < 1; ++i) {
        mplhs[i] = NULL;
    }
    mlfEnterNewContext(0, 0);
    mprhs[0] = NULL;
    mlfAssign(&mprhs[0], mclCreateVararginCell(nrhs, prhs));
    mplhs[0] = Mrecarga_2_3(nlhs, mprhs[0]);
    mclAssignVarargoutCell(0, nlhs, plhs, mplhs[0]);
    mlfRestorePreviousContext(0, 0);
    mxDestroyArray(mprhs[0]);
}

/*
 * The function "mlfRecarga_2_3_RECARGA_2_3_OpeningFcn" contains the normal
 * interface for the "recarga_2_3/RECARGA_2_3_OpeningFcn" M-function from file
 * "u:\final_recarga6\recarga\recarga_2_3.m" (lines 48-83). This function
 * processes any input arguments and passes them to the implementation version
 * of the function, appearing above.
 */
static void mlfRecarga_2_3_RECARGA_2_3_OpeningFcn(mxArray * hObject,
                                                  mxArray * eventdata,
                                                  mxArray * handles,
                                                  ...) {
    mxArray * varargin = NULL;
    mlfVarargin(&varargin, handles, 0);
    mlfEnterNewContext(0, -4, hObject, eventdata, handles, varargin);
    Mrecarga_2_3_RECARGA_2_3_OpeningFcn(hObject, eventdata, handles, varargin);
    mlfRestorePreviousContext(0, 3, hObject, eventdata, handles);
    mxDestroyArray(varargin);
}

/*
 * The function "mlxRecarga_2_3_RECARGA_2_3_OpeningFcn" contains the feval
 * interface for the "recarga_2_3/RECARGA_2_3_OpeningFcn" M-function from file
 * "u:\final_recarga6\recarga\recarga_2_3.m" (lines 48-83). The feval function
 * calls the implementation version of recarga_2_3/RECARGA_2_3_OpeningFcn
 * through this function. This function processes any input arguments and
 * passes them to the implementation version of the function, appearing above.
 */
static void mlxRecarga_2_3_RECARGA_2_3_OpeningFcn(int nlhs,
                                                  mxArray * plhs[],
                                                  int nrhs,
                                                  mxArray * prhs[]) {
    mxArray * mprhs[4];
    int i;
    if (nlhs > 0) {
        mlfError(
          mxCreateString(
            "Run-time Error: File: recarga_2_3/RECARGA_2_3_OpeningFcn Line: 4"
            "8 Column: 1 The function \"recarga_2_3/RECARGA_2_3_OpeningFcn\" "
            "was called with more than the declared number of outputs (0)."),
          NULL);
    }
    for (i = 0; i < 3 && i < nrhs; ++i) {
        mprhs[i] = prhs[i];
    }
    for (; i < 3; ++i) {
        mprhs[i] = NULL;
    }
    mlfEnterNewContext(0, 3, mprhs[0], mprhs[1], mprhs[2]);
    mprhs[3] = NULL;
    mlfAssign(&mprhs[3], mclCreateVararginCell(nrhs - 3, prhs + 3));
    Mrecarga_2_3_RECARGA_2_3_OpeningFcn(mprhs[0], mprhs[1], mprhs[2], mprhs[3]);
    mlfRestorePreviousContext(0, 3, mprhs[0], mprhs[1], mprhs[2]);
    mxDestroyArray(mprhs[3]);
}

/*
 * The function "mlfRecarga_2_3_RECARGA_2_3_OutputFcn" contains the normal
 * interface for the "recarga_2_3/RECARGA_2_3_OutputFcn" M-function from file
 * "u:\final_recarga6\recarga\recarga_2_3.m" (lines 83-92). This function
 * processes any input arguments and passes them to the implementation version
 * of the function, appearing above.
 */
static mxArray * mlfRecarga_2_3_RECARGA_2_3_OutputFcn(mlfVarargoutList * varargout,
                                                      mxArray * hObject,
                                                      mxArray * eventdata,
                                                      mxArray * handles) {
    int nargout = 0;
    mlfEnterNewContext(0, 3, hObject, eventdata, handles);
    nargout += mclNargout(varargout);
    *mlfGetVarargoutCellPtr(varargout)
      = Mrecarga_2_3_RECARGA_2_3_OutputFcn(
          nargout, hObject, eventdata, handles);
    mlfRestorePreviousContext(0, 3, hObject, eventdata, handles);
    return mlfAssignOutputs(varargout);
}

/*
 * The function "mlxRecarga_2_3_RECARGA_2_3_OutputFcn" contains the feval
 * interface for the "recarga_2_3/RECARGA_2_3_OutputFcn" M-function from file
 * "u:\final_recarga6\recarga\recarga_2_3.m" (lines 83-92). The feval function
 * calls the implementation version of recarga_2_3/RECARGA_2_3_OutputFcn
 * through this function. This function processes any input arguments and
 * passes them to the implementation version of the function, appearing above.
 */
static void mlxRecarga_2_3_RECARGA_2_3_OutputFcn(int nlhs,
                                                 mxArray * plhs[],
                                                 int nrhs,
                                                 mxArray * prhs[]) {
    mxArray * mprhs[3];
    mxArray * mplhs[1];
    int i;
    if (nrhs > 3) {
        mlfError(
          mxCreateString(
            "Run-time Error: File: recarga_2_3/RECARGA_2_3_OutputFcn Line: 8"
            "3 Column: 1 The function \"recarga_2_3/RECARGA_2_3_OutputFcn\" "
            "was called with more than the declared number of inputs (3)."),
          NULL);
    }
    for (i = 0; i < 1; ++i) {
        mplhs[i] = NULL;
    }
    for (i = 0; i < 3 && i < nrhs; ++i) {
        mprhs[i] = prhs[i];
    }
    for (; i < 3; ++i) {
        mprhs[i] = NULL;
    }
    mlfEnterNewContext(0, 3, mprhs[0], mprhs[1], mprhs[2]);
    mplhs[0]
      = Mrecarga_2_3_RECARGA_2_3_OutputFcn(nlhs, mprhs[0], mprhs[1], mprhs[2]);
    mclAssignVarargoutCell(0, nlhs, plhs, mplhs[0]);
    mlfRestorePreviousContext(0, 3, mprhs[0], mprhs[1], mprhs[2]);
}

/*
 * The function "mlfRecarga_2_3_Process_Callback" contains the normal interface
 * for the "recarga_2_3/Process_Callback" M-function from file
 * "u:\final_recarga6\recarga\recarga_2_3.m" (lines 92-102). This function
 * processes any input arguments and passes them to the implementation version
 * of the function, appearing above.
 */
static void mlfRecarga_2_3_Process_Callback(mxArray * hObject,
                                            mxArray * eventdata,
                                            mxArray * handles) {
    mlfEnterNewContext(0, 3, hObject, eventdata, handles);
    Mrecarga_2_3_Process_Callback(hObject, eventdata, handles);
    mlfRestorePreviousContext(0, 3, hObject, eventdata, handles);
}

/*
 * The function "mlxRecarga_2_3_Process_Callback" contains the feval interface
 * for the "recarga_2_3/Process_Callback" M-function from file
 * "u:\final_recarga6\recarga\recarga_2_3.m" (lines 92-102). The feval function
 * calls the implementation version of recarga_2_3/Process_Callback through
 * this function. This function processes any input arguments and passes them
 * to the implementation version of the function, appearing above.
 */
static void mlxRecarga_2_3_Process_Callback(int nlhs,
                                            mxArray * plhs[],
                                            int nrhs,
                                            mxArray * prhs[]) {
    mxArray * mprhs[3];
    int i;
    if (nlhs > 0) {
        mlfError(
          mxCreateString(
            "Run-time Error: File: recarga_2_3/Process_Callback Line: 92 "
            "Column: 1 The function \"recarga_2_3/Process_Callback\" was "
            "called with more than the declared number of outputs (0)."),
          NULL);
    }
    if (nrhs > 3) {
        mlfError(
          mxCreateString(
            "Run-time Error: File: recarga_2_3/Process_Callback Line: 92 "
            "Column: 1 The function \"recarga_2_3/Process_Callback\" was "
            "called with more than the declared number of inputs (3)."),
          NULL);
    }
    for (i = 0; i < 3 && i < nrhs; ++i) {
        mprhs[i] = prhs[i];
    }
    for (; i < 3; ++i) {
        mprhs[i] = NULL;
    }
    mlfEnterNewContext(0, 3, mprhs[0], mprhs[1], mprhs[2]);
    Mrecarga_2_3_Process_Callback(mprhs[0], mprhs[1], mprhs[2]);
    mlfRestorePreviousContext(0, 3, mprhs[0], mprhs[1], mprhs[2]);
}

/*
 * The function "mlfRecarga_2_3_Progress_CreateFcn" contains the normal
 * interface for the "recarga_2_3/Progress_CreateFcn" M-function from file
 * "u:\final_recarga6\recarga\recarga_2_3.m" (lines 102-117). This function
 * processes any input arguments and passes them to the implementation version
 * of the function, appearing above.
 */
static void mlfRecarga_2_3_Progress_CreateFcn(mxArray * hObject,
                                              mxArray * eventdata,
                                              mxArray * handles) {
    mlfEnterNewContext(0, 3, hObject, eventdata, handles);
    Mrecarga_2_3_Progress_CreateFcn(hObject, eventdata, handles);
    mlfRestorePreviousContext(0, 3, hObject, eventdata, handles);
}

/*
 * The function "mlxRecarga_2_3_Progress_CreateFcn" contains the feval
 * interface for the "recarga_2_3/Progress_CreateFcn" M-function from file
 * "u:\final_recarga6\recarga\recarga_2_3.m" (lines 102-117). The feval
 * function calls the implementation version of recarga_2_3/Progress_CreateFcn
 * through this function. This function processes any input arguments and
 * passes them to the implementation version of the function, appearing above.
 */
static void mlxRecarga_2_3_Progress_CreateFcn(int nlhs,
                                              mxArray * plhs[],
                                              int nrhs,
                                              mxArray * prhs[]) {
    mxArray * mprhs[3];
    int i;
    if (nlhs > 0) {
        mlfError(
          mxCreateString(
            "Run-time Error: File: recarga_2_3/Progress_CreateFcn Line: 102"
            " Column: 1 The function \"recarga_2_3/Progress_CreateFcn\" was"
            " called with more than the declared number of outputs (0)."),
          NULL);
    }
    if (nrhs > 3) {
        mlfError(
          mxCreateString(
            "Run-time Error: File: recarga_2_3/Progress_CreateFcn Line: 10"
            "2 Column: 1 The function \"recarga_2_3/Progress_CreateFcn\" w"
            "as called with more than the declared number of inputs (3)."),
          NULL);
    }
    for (i = 0; i < 3 && i < nrhs; ++i) {
        mprhs[i] = prhs[i];
    }
    for (; i < 3; ++i) {
        mprhs[i] = NULL;
    }
    mlfEnterNewContext(0, 3, mprhs[0], mprhs[1], mprhs[2]);
    Mrecarga_2_3_Progress_CreateFcn(mprhs[0], mprhs[1], mprhs[2]);
    mlfRestorePreviousContext(0, 3, mprhs[0], mprhs[1], mprhs[2]);
}

/*
 * The function "mlfRecarga_2_3_Progress_Callback" contains the normal
 * interface for the "recarga_2_3/Progress_Callback" M-function from file
 * "u:\final_recarga6\recarga\recarga_2_3.m" (lines 117-127). This function
 * processes any input arguments and passes them to the implementation version
 * of the function, appearing above.
 */
static void mlfRecarga_2_3_Progress_Callback(mxArray * hObject,
                                             mxArray * eventdata,
                                             mxArray * handles) {
    mlfEnterNewContext(0, 3, hObject, eventdata, handles);
    Mrecarga_2_3_Progress_Callback(hObject, eventdata, handles);
    mlfRestorePreviousContext(0, 3, hObject, eventdata, handles);
}

/*
 * The function "mlxRecarga_2_3_Progress_Callback" contains the feval interface
 * for the "recarga_2_3/Progress_Callback" M-function from file
 * "u:\final_recarga6\recarga\recarga_2_3.m" (lines 117-127). The feval
 * function calls the implementation version of recarga_2_3/Progress_Callback
 * through this function. This function processes any input arguments and
 * passes them to the implementation version of the function, appearing above.
 */
static void mlxRecarga_2_3_Progress_Callback(int nlhs,
                                             mxArray * plhs[],
                                             int nrhs,
                                             mxArray * prhs[]) {
    mxArray * mprhs[3];
    int i;
    if (nlhs > 0) {
        mlfError(
          mxCreateString(
            "Run-time Error: File: recarga_2_3/Progress_Callback Line: 117"
            " Column: 1 The function \"recarga_2_3/Progress_Callback\" was"
            " called with more than the declared number of outputs (0)."),
          NULL);
    }
    if (nrhs > 3) {
        mlfError(
          mxCreateString(
            "Run-time Error: File: recarga_2_3/Progress_Callback Line: 117"
            " Column: 1 The function \"recarga_2_3/Progress_Callback\" was"
            " called with more than the declared number of inputs (3)."),
          NULL);
    }
    for (i = 0; i < 3 && i < nrhs; ++i) {
        mprhs[i] = prhs[i];
    }
    for (; i < 3; ++i) {
        mprhs[i] = NULL;
    }
    mlfEnterNewContext(0, 3, mprhs[0], mprhs[1], mprhs[2]);
    Mrecarga_2_3_Progress_Callback(mprhs[0], mprhs[1], mprhs[2]);
    mlfRestorePreviousContext(0, 3, mprhs[0], mprhs[1], mprhs[2]);
}

/*
 * The function "mlfRecarga_2_3_Runon_CreateFcn" contains the normal interface
 * for the "recarga_2_3/Runon_CreateFcn" M-function from file
 * "u:\final_recarga6\recarga\recarga_2_3.m" (lines 127-142). This function
 * processes any input arguments and passes them to the implementation version
 * of the function, appearing above.
 */
static void mlfRecarga_2_3_Runon_CreateFcn(mxArray * hObject,
                                           mxArray * eventdata,
                                           mxArray * handles) {
    mlfEnterNewContext(0, 3, hObject, eventdata, handles);
    Mrecarga_2_3_Runon_CreateFcn(hObject, eventdata, handles);
    mlfRestorePreviousContext(0, 3, hObject, eventdata, handles);
}

/*
 * The function "mlxRecarga_2_3_Runon_CreateFcn" contains the feval interface
 * for the "recarga_2_3/Runon_CreateFcn" M-function from file
 * "u:\final_recarga6\recarga\recarga_2_3.m" (lines 127-142). The feval
 * function calls the implementation version of recarga_2_3/Runon_CreateFcn
 * through this function. This function processes any input arguments and
 * passes them to the implementation version of the function, appearing above.
 */
static void mlxRecarga_2_3_Runon_CreateFcn(int nlhs,
                                           mxArray * plhs[],
                                           int nrhs,
                                           mxArray * prhs[]) {
    mxArray * mprhs[3];
    int i;
    if (nlhs > 0) {
        mlfError(
          mxCreateString(
            "Run-time Error: File: recarga_2_3/Runon_CreateFcn Line: 127 "
            "Column: 1 The function \"recarga_2_3/Runon_CreateFcn\" was c"
            "alled with more than the declared number of outputs (0)."),
          NULL);
    }
    if (nrhs > 3) {
        mlfError(
          mxCreateString(
            "Run-time Error: File: recarga_2_3/Runon_CreateFcn Line: 127"
            " Column: 1 The function \"recarga_2_3/Runon_CreateFcn\" was"
            " called with more than the declared number of inputs (3)."),
          NULL);
    }
    for (i = 0; i < 3 && i < nrhs; ++i) {
        mprhs[i] = prhs[i];
    }
    for (; i < 3; ++i) {
        mprhs[i] = NULL;
    }
    mlfEnterNewContext(0, 3, mprhs[0], mprhs[1], mprhs[2]);
    Mrecarga_2_3_Runon_CreateFcn(mprhs[0], mprhs[1], mprhs[2]);
    mlfRestorePreviousContext(0, 3, mprhs[0], mprhs[1], mprhs[2]);
}

/*
 * The function "mlfRecarga_2_3_Runon_Callback" contains the normal interface
 * for the "recarga_2_3/Runon_Callback" M-function from file
 * "u:\final_recarga6\recarga\recarga_2_3.m" (lines 142-152). This function
 * processes any input arguments and passes them to the implementation version
 * of the function, appearing above.
 */
static void mlfRecarga_2_3_Runon_Callback(mxArray * hObject,
                                          mxArray * eventdata,
                                          mxArray * handles) {
    mlfEnterNewContext(0, 3, hObject, eventdata, handles);
    Mrecarga_2_3_Runon_Callback(hObject, eventdata, handles);
    mlfRestorePreviousContext(0, 3, hObject, eventdata, handles);
}

/*
 * The function "mlxRecarga_2_3_Runon_Callback" contains the feval interface
 * for the "recarga_2_3/Runon_Callback" M-function from file
 * "u:\final_recarga6\recarga\recarga_2_3.m" (lines 142-152). The feval
 * function calls the implementation version of recarga_2_3/Runon_Callback
 * through this function. This function processes any input arguments and
 * passes them to the implementation version of the function, appearing above.
 */
static void mlxRecarga_2_3_Runon_Callback(int nlhs,
                                          mxArray * plhs[],
                                          int nrhs,
                                          mxArray * prhs[]) {
    mxArray * mprhs[3];
    int i;
    if (nlhs > 0) {
        mlfError(
          mxCreateString(
            "Run-time Error: File: recarga_2_3/Runon_Callback Line: 142 "
            "Column: 1 The function \"recarga_2_3/Runon_Callback\" was c"
            "alled with more than the declared number of outputs (0)."),
          NULL);
    }
    if (nrhs > 3) {
        mlfError(
          mxCreateString(
            "Run-time Error: File: recarga_2_3/Runon_Callback Line: 142 "
            "Column: 1 The function \"recarga_2_3/Runon_Callback\" was c"
            "alled with more than the declared number of inputs (3)."),
          NULL);
    }
    for (i = 0; i < 3 && i < nrhs; ++i) {
        mprhs[i] = prhs[i];
    }
    for (; i < 3; ++i) {
        mprhs[i] = NULL;
    }
    mlfEnterNewContext(0, 3, mprhs[0], mprhs[1], mprhs[2]);
    Mrecarga_2_3_Runon_Callback(mprhs[0], mprhs[1], mprhs[2]);
    mlfRestorePreviousContext(0, 3, mprhs[0], mprhs[1], mprhs[2]);
}

/*
 * The function "mlfRecarga_2_3_Runoff_CreateFcn" contains the normal interface
 * for the "recarga_2_3/Runoff_CreateFcn" M-function from file
 * "u:\final_recarga6\recarga\recarga_2_3.m" (lines 152-167). This function
 * processes any input arguments and passes them to the implementation version
 * of the function, appearing above.
 */
static void mlfRecarga_2_3_Runoff_CreateFcn(mxArray * hObject,
                                            mxArray * eventdata,
                                            mxArray * handles) {
    mlfEnterNewContext(0, 3, hObject, eventdata, handles);
    Mrecarga_2_3_Runoff_CreateFcn(hObject, eventdata, handles);
    mlfRestorePreviousContext(0, 3, hObject, eventdata, handles);
}

/*
 * The function "mlxRecarga_2_3_Runoff_CreateFcn" contains the feval interface
 * for the "recarga_2_3/Runoff_CreateFcn" M-function from file
 * "u:\final_recarga6\recarga\recarga_2_3.m" (lines 152-167). The feval
 * function calls the implementation version of recarga_2_3/Runoff_CreateFcn
 * through this function. This function processes any input arguments and
 * passes them to the implementation version of the function, appearing above.
 */
static void mlxRecarga_2_3_Runoff_CreateFcn(int nlhs,
                                            mxArray * plhs[],
                                            int nrhs,
                                            mxArray * prhs[]) {
    mxArray * mprhs[3];
    int i;
    if (nlhs > 0) {
        mlfError(
          mxCreateString(
            "Run-time Error: File: recarga_2_3/Runoff_CreateFcn Line: 152"
            " Column: 1 The function \"recarga_2_3/Runoff_CreateFcn\" was"
            " called with more than the declared number of outputs (0)."),
          NULL);
    }
    if (nrhs > 3) {
        mlfError(
          mxCreateString(
            "Run-time Error: File: recarga_2_3/Runoff_CreateFcn Line: 152"
            " Column: 1 The function \"recarga_2_3/Runoff_CreateFcn\" was"
            " called with more than the declared number of inputs (3)."),
          NULL);
    }
    for (i = 0; i < 3 && i < nrhs; ++i) {
        mprhs[i] = prhs[i];
    }
    for (; i < 3; ++i) {
        mprhs[i] = NULL;
    }
    mlfEnterNewContext(0, 3, mprhs[0], mprhs[1], mprhs[2]);
    Mrecarga_2_3_Runoff_CreateFcn(mprhs[0], mprhs[1], mprhs[2]);
    mlfRestorePreviousContext(0, 3, mprhs[0], mprhs[1], mprhs[2]);
}

/*
 * The function "mlfRecarga_2_3_Runoff_Callback" contains the normal interface
 * for the "recarga_2_3/Runoff_Callback" M-function from file
 * "u:\final_recarga6\recarga\recarga_2_3.m" (lines 167-177). This function
 * processes any input arguments and passes them to the implementation version
 * of the function, appearing above.
 */
static void mlfRecarga_2_3_Runoff_Callback(mxArray * hObject,
                                           mxArray * eventdata,
                                           mxArray * handles) {
    mlfEnterNewContext(0, 3, hObject, eventdata, handles);
    Mrecarga_2_3_Runoff_Callback(hObject, eventdata, handles);
    mlfRestorePreviousContext(0, 3, hObject, eventdata, handles);
}

/*
 * The function "mlxRecarga_2_3_Runoff_Callback" contains the feval interface
 * for the "recarga_2_3/Runoff_Callback" M-function from file
 * "u:\final_recarga6\recarga\recarga_2_3.m" (lines 167-177). The feval
 * function calls the implementation version of recarga_2_3/Runoff_Callback
 * through this function. This function processes any input arguments and
 * passes them to the implementation version of the function, appearing above.
 */
static void mlxRecarga_2_3_Runoff_Callback(int nlhs,
                                           mxArray * plhs[],
                                           int nrhs,
                                           mxArray * prhs[]) {
    mxArray * mprhs[3];
    int i;
    if (nlhs > 0) {
        mlfError(
          mxCreateString(
            "Run-time Error: File: recarga_2_3/Runoff_Callback Line: 167 "
            "Column: 1 The function \"recarga_2_3/Runoff_Callback\" was c"
            "alled with more than the declared number of outputs (0)."),
          NULL);
    }
    if (nrhs > 3) {
        mlfError(
          mxCreateString(
            "Run-time Error: File: recarga_2_3/Runoff_Callback Line: 167"
            " Column: 1 The function \"recarga_2_3/Runoff_Callback\" was"
            " called with more than the declared number of inputs (3)."),
          NULL);
    }
    for (i = 0; i < 3 && i < nrhs; ++i) {
        mprhs[i] = prhs[i];
    }
    for (; i < 3; ++i) {
        mprhs[i] = NULL;
    }
    mlfEnterNewContext(0, 3, mprhs[0], mprhs[1], mprhs[2]);
    Mrecarga_2_3_Runoff_Callback(mprhs[0], mprhs[1], mprhs[2]);
    mlfRestorePreviousContext(0, 3, mprhs[0], mprhs[1], mprhs[2]);
}

/*
 * The function "mlfRecarga_2_3_Recharge_CreateFcn" contains the normal
 * interface for the "recarga_2_3/Recharge_CreateFcn" M-function from file
 * "u:\final_recarga6\recarga\recarga_2_3.m" (lines 177-192). This function
 * processes any input arguments and passes them to the implementation version
 * of the function, appearing above.
 */
static void mlfRecarga_2_3_Recharge_CreateFcn(mxArray * hObject,
                                              mxArray * eventdata,
                                              mxArray * handles) {
    mlfEnterNewContext(0, 3, hObject, eventdata, handles);
    Mrecarga_2_3_Recharge_CreateFcn(hObject, eventdata, handles);
    mlfRestorePreviousContext(0, 3, hObject, eventdata, handles);
}

/*
 * The function "mlxRecarga_2_3_Recharge_CreateFcn" contains the feval
 * interface for the "recarga_2_3/Recharge_CreateFcn" M-function from file
 * "u:\final_recarga6\recarga\recarga_2_3.m" (lines 177-192). The feval
 * function calls the implementation version of recarga_2_3/Recharge_CreateFcn
 * through this function. This function processes any input arguments and
 * passes them to the implementation version of the function, appearing above.
 */
static void mlxRecarga_2_3_Recharge_CreateFcn(int nlhs,
                                              mxArray * plhs[],
                                              int nrhs,
                                              mxArray * prhs[]) {
    mxArray * mprhs[3];
    int i;
    if (nlhs > 0) {
        mlfError(
          mxCreateString(
            "Run-time Error: File: recarga_2_3/Recharge_CreateFcn Line: 177"
            " Column: 1 The function \"recarga_2_3/Recharge_CreateFcn\" was"
            " called with more than the declared number of outputs (0)."),
          NULL);
    }
    if (nrhs > 3) {
        mlfError(
          mxCreateString(
            "Run-time Error: File: recarga_2_3/Recharge_CreateFcn Line: 17"
            "7 Column: 1 The function \"recarga_2_3/Recharge_CreateFcn\" w"
            "as called with more than the declared number of inputs (3)."),
          NULL);
    }
    for (i = 0; i < 3 && i < nrhs; ++i) {
        mprhs[i] = prhs[i];
    }
    for (; i < 3; ++i) {
        mprhs[i] = NULL;
    }
    mlfEnterNewContext(0, 3, mprhs[0], mprhs[1], mprhs[2]);
    Mrecarga_2_3_Recharge_CreateFcn(mprhs[0], mprhs[1], mprhs[2]);
    mlfRestorePreviousContext(0, 3, mprhs[0], mprhs[1], mprhs[2]);
}

/*
 * The function "mlfRecarga_2_3_Recharge_Callback" contains the normal
 * interface for the "recarga_2_3/Recharge_Callback" M-function from file
 * "u:\final_recarga6\recarga\recarga_2_3.m" (lines 192-202). This function
 * processes any input arguments and passes them to the implementation version
 * of the function, appearing above.
 */
static void mlfRecarga_2_3_Recharge_Callback(mxArray * hObject,
                                             mxArray * eventdata,
                                             mxArray * handles) {
    mlfEnterNewContext(0, 3, hObject, eventdata, handles);
    Mrecarga_2_3_Recharge_Callback(hObject, eventdata, handles);
    mlfRestorePreviousContext(0, 3, hObject, eventdata, handles);
}

/*
 * The function "mlxRecarga_2_3_Recharge_Callback" contains the feval interface
 * for the "recarga_2_3/Recharge_Callback" M-function from file
 * "u:\final_recarga6\recarga\recarga_2_3.m" (lines 192-202). The feval
 * function calls the implementation version of recarga_2_3/Recharge_Callback
 * through this function. This function processes any input arguments and
 * passes them to the implementation version of the function, appearing above.
 */
static void mlxRecarga_2_3_Recharge_Callback(int nlhs,
                                             mxArray * plhs[],
                                             int nrhs,
                                             mxArray * prhs[]) {
    mxArray * mprhs[3];
    int i;
    if (nlhs > 0) {
        mlfError(
          mxCreateString(
            "Run-time Error: File: recarga_2_3/Recharge_Callback Line: 192"
            " Column: 1 The function \"recarga_2_3/Recharge_Callback\" was"
            " called with more than the declared number of outputs (0)."),
          NULL);
    }
    if (nrhs > 3) {
        mlfError(
          mxCreateString(
            "Run-time Error: File: recarga_2_3/Recharge_Callback Line: 192"
            " Column: 1 The function \"recarga_2_3/Recharge_Callback\" was"
            " called with more than the declared number of inputs (3)."),
          NULL);
    }
    for (i = 0; i < 3 && i < nrhs; ++i) {
        mprhs[i] = prhs[i];
    }
    for (; i < 3; ++i) {
        mprhs[i] = NULL;
    }
    mlfEnterNewContext(0, 3, mprhs[0], mprhs[1], mprhs[2]);
    Mrecarga_2_3_Recharge_Callback(mprhs[0], mprhs[1], mprhs[2]);
    mlfRestorePreviousContext(0, 3, mprhs[0], mprhs[1], mprhs[2]);
}

/*
 * The function "mlfRecarga_2_3_Evap_CreateFcn" contains the normal interface
 * for the "recarga_2_3/Evap_CreateFcn" M-function from file
 * "u:\final_recarga6\recarga\recarga_2_3.m" (lines 202-217). This function
 * processes any input arguments and passes them to the implementation version
 * of the function, appearing above.
 */
static void mlfRecarga_2_3_Evap_CreateFcn(mxArray * hObject,
                                          mxArray * eventdata,
                                          mxArray * handles) {
    mlfEnterNewContext(0, 3, hObject, eventdata, handles);
    Mrecarga_2_3_Evap_CreateFcn(hObject, eventdata, handles);
    mlfRestorePreviousContext(0, 3, hObject, eventdata, handles);
}

/*
 * The function "mlxRecarga_2_3_Evap_CreateFcn" contains the feval interface
 * for the "recarga_2_3/Evap_CreateFcn" M-function from file
 * "u:\final_recarga6\recarga\recarga_2_3.m" (lines 202-217). The feval
 * function calls the implementation version of recarga_2_3/Evap_CreateFcn
 * through this function. This function processes any input arguments and
 * passes them to the implementation version of the function, appearing above.
 */
static void mlxRecarga_2_3_Evap_CreateFcn(int nlhs,
                                          mxArray * plhs[],
                                          int nrhs,
                                          mxArray * prhs[]) {
    mxArray * mprhs[3];
    int i;
    if (nlhs > 0) {
        mlfError(
          mxCreateString(
            "Run-time Error: File: recarga_2_3/Evap_CreateFcn Line: 202 "
            "Column: 1 The function \"recarga_2_3/Evap_CreateFcn\" was c"
            "alled with more than the declared number of outputs (0)."),
          NULL);
    }
    if (nrhs > 3) {
        mlfError(
          mxCreateString(
            "Run-time Error: File: recarga_2_3/Evap_CreateFcn Line: 202 "
            "Column: 1 The function \"recarga_2_3/Evap_CreateFcn\" was c"
            "alled with more than the declared number of inputs (3)."),
          NULL);
    }
    for (i = 0; i < 3 && i < nrhs; ++i) {
        mprhs[i] = prhs[i];
    }
    for (; i < 3; ++i) {
        mprhs[i] = NULL;
    }
    mlfEnterNewContext(0, 3, mprhs[0], mprhs[1], mprhs[2]);
    Mrecarga_2_3_Evap_CreateFcn(mprhs[0], mprhs[1], mprhs[2]);
    mlfRestorePreviousContext(0, 3, mprhs[0], mprhs[1], mprhs[2]);
}

/*
 * The function "mlfRecarga_2_3_Evap_Callback" contains the normal interface
 * for the "recarga_2_3/Evap_Callback" M-function from file
 * "u:\final_recarga6\recarga\recarga_2_3.m" (lines 217-227). This function
 * processes any input arguments and passes them to the implementation version
 * of the function, appearing above.
 */
static void mlfRecarga_2_3_Evap_Callback(mxArray * hObject,
                                         mxArray * eventdata,
                                         mxArray * handles) {
    mlfEnterNewContext(0, 3, hObject, eventdata, handles);
    Mrecarga_2_3_Evap_Callback(hObject, eventdata, handles);
    mlfRestorePreviousContext(0, 3, hObject, eventdata, handles);
}

/*
 * The function "mlxRecarga_2_3_Evap_Callback" contains the feval interface for
 * the "recarga_2_3/Evap_Callback" M-function from file
 * "u:\final_recarga6\recarga\recarga_2_3.m" (lines 217-227). The feval
 * function calls the implementation version of recarga_2_3/Evap_Callback
 * through this function. This function processes any input arguments and
 * passes them to the implementation version of the function, appearing above.
 */
static void mlxRecarga_2_3_Evap_Callback(int nlhs,
                                         mxArray * plhs[],
                                         int nrhs,
                                         mxArray * prhs[]) {
    mxArray * mprhs[3];
    int i;
    if (nlhs > 0) {
        mlfError(
          mxCreateString(
            "Run-time Error: File: recarga_2_3/Evap_Callback Line: 217 "
            "Column: 1 The function \"recarga_2_3/Evap_Callback\" was c"
            "alled with more than the declared number of outputs (0)."),
          NULL);
    }
    if (nrhs > 3) {
        mlfError(
          mxCreateString(
            "Run-time Error: File: recarga_2_3/Evap_Callback Line: 217 "
            "Column: 1 The function \"recarga_2_3/Evap_Callback\" was c"
            "alled with more than the declared number of inputs (3)."),
          NULL);
    }
    for (i = 0; i < 3 && i < nrhs; ++i) {
        mprhs[i] = prhs[i];
    }
    for (; i < 3; ++i) {
        mprhs[i] = NULL;
    }
    mlfEnterNewContext(0, 3, mprhs[0], mprhs[1], mprhs[2]);
    Mrecarga_2_3_Evap_Callback(mprhs[0], mprhs[1], mprhs[2]);
    mlfRestorePreviousContext(0, 3, mprhs[0], mprhs[1], mprhs[2]);
}

/*
 * The function "mlfRecarga_2_3_Storage_CreateFcn" contains the normal
 * interface for the "recarga_2_3/Storage_CreateFcn" M-function from file
 * "u:\final_recarga6\recarga\recarga_2_3.m" (lines 227-242). This function
 * processes any input arguments and passes them to the implementation version
 * of the function, appearing above.
 */
static void mlfRecarga_2_3_Storage_CreateFcn(mxArray * hObject,
                                             mxArray * eventdata,
                                             mxArray * handles) {
    mlfEnterNewContext(0, 3, hObject, eventdata, handles);
    Mrecarga_2_3_Storage_CreateFcn(hObject, eventdata, handles);
    mlfRestorePreviousContext(0, 3, hObject, eventdata, handles);
}

/*
 * The function "mlxRecarga_2_3_Storage_CreateFcn" contains the feval interface
 * for the "recarga_2_3/Storage_CreateFcn" M-function from file
 * "u:\final_recarga6\recarga\recarga_2_3.m" (lines 227-242). The feval
 * function calls the implementation version of recarga_2_3/Storage_CreateFcn
 * through this function. This function processes any input arguments and
 * passes them to the implementation version of the function, appearing above.
 */
static void mlxRecarga_2_3_Storage_CreateFcn(int nlhs,
                                             mxArray * plhs[],
                                             int nrhs,
                                             mxArray * prhs[]) {
    mxArray * mprhs[3];
    int i;
    if (nlhs > 0) {
        mlfError(
          mxCreateString(
            "Run-time Error: File: recarga_2_3/Storage_CreateFcn Line: 227"
            " Column: 1 The function \"recarga_2_3/Storage_CreateFcn\" was"
            " called with more than the declared number of outputs (0)."),
          NULL);
    }
    if (nrhs > 3) {
        mlfError(
          mxCreateString(
            "Run-time Error: File: recarga_2_3/Storage_CreateFcn Line: 227"
            " Column: 1 The function \"recarga_2_3/Storage_CreateFcn\" was"
            " called with more than the declared number of inputs (3)."),
          NULL);
    }
    for (i = 0; i < 3 && i < nrhs; ++i) {
        mprhs[i] = prhs[i];
    }
    for (; i < 3; ++i) {
        mprhs[i] = NULL;
    }
    mlfEnterNewContext(0, 3, mprhs[0], mprhs[1], mprhs[2]);
    Mrecarga_2_3_Storage_CreateFcn(mprhs[0], mprhs[1], mprhs[2]);
    mlfRestorePreviousContext(0, 3, mprhs[0], mprhs[1], mprhs[2]);
}

/*
 * The function "mlfRecarga_2_3_Storage_Callback" contains the normal interface
 * for the "recarga_2_3/Storage_Callback" M-function from file
 * "u:\final_recarga6\recarga\recarga_2_3.m" (lines 242-252). This function
 * processes any input arguments and passes them to the implementation version
 * of the function, appearing above.
 */
static void mlfRecarga_2_3_Storage_Callback(mxArray * hObject,
                                            mxArray * eventdata,
                                            mxArray * handles) {
    mlfEnterNewContext(0, 3, hObject, eventdata, handles);
    Mrecarga_2_3_Storage_Callback(hObject, eventdata, handles);
    mlfRestorePreviousContext(0, 3, hObject, eventdata, handles);
}

/*
 * The function "mlxRecarga_2_3_Storage_Callback" contains the feval interface
 * for the "recarga_2_3/Storage_Callback" M-function from file
 * "u:\final_recarga6\recarga\recarga_2_3.m" (lines 242-252). The feval
 * function calls the implementation version of recarga_2_3/Storage_Callback
 * through this function. This function processes any input arguments and
 * passes them to the implementation version of the function, appearing above.
 */
static void mlxRecarga_2_3_Storage_Callback(int nlhs,
                                            mxArray * plhs[],
                                            int nrhs,
                                            mxArray * prhs[]) {
    mxArray * mprhs[3];
    int i;
    if (nlhs > 0) {
        mlfError(
          mxCreateString(
            "Run-time Error: File: recarga_2_3/Storage_Callback Line: 242"
            " Column: 1 The function \"recarga_2_3/Storage_Callback\" was"
            " called with more than the declared number of outputs (0)."),
          NULL);
    }
    if (nrhs > 3) {
        mlfError(
          mxCreateString(
            "Run-time Error: File: recarga_2_3/Storage_Callback Line: 242"
            " Column: 1 The function \"recarga_2_3/Storage_Callback\" was"
            " called with more than the declared number of inputs (3)."),
          NULL);
    }
    for (i = 0; i < 3 && i < nrhs; ++i) {
        mprhs[i] = prhs[i];
    }
    for (; i < 3; ++i) {
        mprhs[i] = NULL;
    }
    mlfEnterNewContext(0, 3, mprhs[0], mprhs[1], mprhs[2]);
    Mrecarga_2_3_Storage_Callback(mprhs[0], mprhs[1], mprhs[2]);
    mlfRestorePreviousContext(0, 3, mprhs[0], mprhs[1], mprhs[2]);
}

/*
 * The function "mlfRecarga_2_3_Prunon_CreateFcn" contains the normal interface
 * for the "recarga_2_3/Prunon_CreateFcn" M-function from file
 * "u:\final_recarga6\recarga\recarga_2_3.m" (lines 252-267). This function
 * processes any input arguments and passes them to the implementation version
 * of the function, appearing above.
 */
static void mlfRecarga_2_3_Prunon_CreateFcn(mxArray * hObject,
                                            mxArray * eventdata,
                                            mxArray * handles) {
    mlfEnterNewContext(0, 3, hObject, eventdata, handles);
    Mrecarga_2_3_Prunon_CreateFcn(hObject, eventdata, handles);
    mlfRestorePreviousContext(0, 3, hObject, eventdata, handles);
}

/*
 * The function "mlxRecarga_2_3_Prunon_CreateFcn" contains the feval interface
 * for the "recarga_2_3/Prunon_CreateFcn" M-function from file
 * "u:\final_recarga6\recarga\recarga_2_3.m" (lines 252-267). The feval
 * function calls the implementation version of recarga_2_3/Prunon_CreateFcn
 * through this function. This function processes any input arguments and
 * passes them to the implementation version of the function, appearing above.
 */
static void mlxRecarga_2_3_Prunon_CreateFcn(int nlhs,
                                            mxArray * plhs[],
                                            int nrhs,
                                            mxArray * prhs[]) {
    mxArray * mprhs[3];
    int i;
    if (nlhs > 0) {
        mlfError(
          mxCreateString(
            "Run-time Error: File: recarga_2_3/Prunon_CreateFcn Line: 252"
            " Column: 1 The function \"recarga_2_3/Prunon_CreateFcn\" was"
            " called with more than the declared number of outputs (0)."),
          NULL);
    }
    if (nrhs > 3) {
        mlfError(
          mxCreateString(
            "Run-time Error: File: recarga_2_3/Prunon_CreateFcn Line: 252"
            " Column: 1 The function \"recarga_2_3/Prunon_CreateFcn\" was"
            " called with more than the declared number of inputs (3)."),
          NULL);
    }
    for (i = 0; i < 3 && i < nrhs; ++i) {
        mprhs[i] = prhs[i];
    }
    for (; i < 3; ++i) {
        mprhs[i] = NULL;
    }
    mlfEnterNewContext(0, 3, mprhs[0], mprhs[1], mprhs[2]);
    Mrecarga_2_3_Prunon_CreateFcn(mprhs[0], mprhs[1], mprhs[2]);
    mlfRestorePreviousContext(0, 3, mprhs[0], mprhs[1], mprhs[2]);
}

/*
 * The function "mlfRecarga_2_3_Prunon_Callback" contains the normal interface
 * for the "recarga_2_3/Prunon_Callback" M-function from file
 * "u:\final_recarga6\recarga\recarga_2_3.m" (lines 267-277). This function
 * processes any input arguments and passes them to the implementation version
 * of the function, appearing above.
 */
static void mlfRecarga_2_3_Prunon_Callback(mxArray * hObject,
                                           mxArray * eventdata,
                                           mxArray * handles) {
    mlfEnterNewContext(0, 3, hObject, eventdata, handles);
    Mrecarga_2_3_Prunon_Callback(hObject, eventdata, handles);
    mlfRestorePreviousContext(0, 3, hObject, eventdata, handles);
}

/*
 * The function "mlxRecarga_2_3_Prunon_Callback" contains the feval interface
 * for the "recarga_2_3/Prunon_Callback" M-function from file
 * "u:\final_recarga6\recarga\recarga_2_3.m" (lines 267-277). The feval
 * function calls the implementation version of recarga_2_3/Prunon_Callback
 * through this function. This function processes any input arguments and
 * passes them to the implementation version of the function, appearing above.
 */
static void mlxRecarga_2_3_Prunon_Callback(int nlhs,
                                           mxArray * plhs[],
                                           int nrhs,
                                           mxArray * prhs[]) {
    mxArray * mprhs[3];
    int i;
    if (nlhs > 0) {
        mlfError(
          mxCreateString(
            "Run-time Error: File: recarga_2_3/Prunon_Callback Line: 267 "
            "Column: 1 The function \"recarga_2_3/Prunon_Callback\" was c"
            "alled with more than the declared number of outputs (0)."),
          NULL);
    }
    if (nrhs > 3) {
        mlfError(
          mxCreateString(
            "Run-time Error: File: recarga_2_3/Prunon_Callback Line: 267"
            " Column: 1 The function \"recarga_2_3/Prunon_Callback\" was"
            " called with more than the declared number of inputs (3)."),
          NULL);
    }
    for (i = 0; i < 3 && i < nrhs; ++i) {
        mprhs[i] = prhs[i];
    }
    for (; i < 3; ++i) {
        mprhs[i] = NULL;
    }
    mlfEnterNewContext(0, 3, mprhs[0], mprhs[1], mprhs[2]);
    Mrecarga_2_3_Prunon_Callback(mprhs[0], mprhs[1], mprhs[2]);
    mlfRestorePreviousContext(0, 3, mprhs[0], mprhs[1], mprhs[2]);
}

/*
 * The function "mlfRecarga_2_3_Prunoff_CreateFcn" contains the normal
 * interface for the "recarga_2_3/Prunoff_CreateFcn" M-function from file
 * "u:\final_recarga6\recarga\recarga_2_3.m" (lines 277-292). This function
 * processes any input arguments and passes them to the implementation version
 * of the function, appearing above.
 */
static void mlfRecarga_2_3_Prunoff_CreateFcn(mxArray * hObject,
                                             mxArray * eventdata,
                                             mxArray * handles) {
    mlfEnterNewContext(0, 3, hObject, eventdata, handles);
    Mrecarga_2_3_Prunoff_CreateFcn(hObject, eventdata, handles);
    mlfRestorePreviousContext(0, 3, hObject, eventdata, handles);
}

/*
 * The function "mlxRecarga_2_3_Prunoff_CreateFcn" contains the feval interface
 * for the "recarga_2_3/Prunoff_CreateFcn" M-function from file
 * "u:\final_recarga6\recarga\recarga_2_3.m" (lines 277-292). The feval
 * function calls the implementation version of recarga_2_3/Prunoff_CreateFcn
 * through this function. This function processes any input arguments and
 * passes them to the implementation version of the function, appearing above.
 */
static void mlxRecarga_2_3_Prunoff_CreateFcn(int nlhs,
                                             mxArray * plhs[],
                                             int nrhs,
                                             mxArray * prhs[]) {
    mxArray * mprhs[3];
    int i;
    if (nlhs > 0) {
        mlfError(
          mxCreateString(
            "Run-time Error: File: recarga_2_3/Prunoff_CreateFcn Line: 277"
            " Column: 1 The function \"recarga_2_3/Prunoff_CreateFcn\" was"
            " called with more than the declared number of outputs (0)."),
          NULL);
    }
    if (nrhs > 3) {
        mlfError(
          mxCreateString(
            "Run-time Error: File: recarga_2_3/Prunoff_CreateFcn Line: 277"
            " Column: 1 The function \"recarga_2_3/Prunoff_CreateFcn\" was"
            " called with more than the declared number of inputs (3)."),
          NULL);
    }
    for (i = 0; i < 3 && i < nrhs; ++i) {
        mprhs[i] = prhs[i];
    }
    for (; i < 3; ++i) {
        mprhs[i] = NULL;
    }
    mlfEnterNewContext(0, 3, mprhs[0], mprhs[1], mprhs[2]);
    Mrecarga_2_3_Prunoff_CreateFcn(mprhs[0], mprhs[1], mprhs[2]);
    mlfRestorePreviousContext(0, 3, mprhs[0], mprhs[1], mprhs[2]);
}

/*
 * The function "mlfRecarga_2_3_Prunoff_Callback" contains the normal interface
 * for the "recarga_2_3/Prunoff_Callback" M-function from file
 * "u:\final_recarga6\recarga\recarga_2_3.m" (lines 292-302). This function
 * processes any input arguments and passes them to the implementation version
 * of the function, appearing above.
 */
static void mlfRecarga_2_3_Prunoff_Callback(mxArray * hObject,
                                            mxArray * eventdata,
                                            mxArray * handles) {
    mlfEnterNewContext(0, 3, hObject, eventdata, handles);
    Mrecarga_2_3_Prunoff_Callback(hObject, eventdata, handles);
    mlfRestorePreviousContext(0, 3, hObject, eventdata, handles);
}

/*
 * The function "mlxRecarga_2_3_Prunoff_Callback" contains the feval interface
 * for the "recarga_2_3/Prunoff_Callback" M-function from file
 * "u:\final_recarga6\recarga\recarga_2_3.m" (lines 292-302). The feval
 * function calls the implementation version of recarga_2_3/Prunoff_Callback
 * through this function. This function processes any input arguments and
 * passes them to the implementation version of the function, appearing above.
 */
static void mlxRecarga_2_3_Prunoff_Callback(int nlhs,
                                            mxArray * plhs[],
                                            int nrhs,
                                            mxArray * prhs[]) {
    mxArray * mprhs[3];
    int i;
    if (nlhs > 0) {
        mlfError(
          mxCreateString(
            "Run-time Error: File: recarga_2_3/Prunoff_Callback Line: 292"
            " Column: 1 The function \"recarga_2_3/Prunoff_Callback\" was"
            " called with more than the declared number of outputs (0)."),
          NULL);
    }
    if (nrhs > 3) {
        mlfError(
          mxCreateString(
            "Run-time Error: File: recarga_2_3/Prunoff_Callback Line: 292"
            " Column: 1 The function \"recarga_2_3/Prunoff_Callback\" was"
            " called with more than the declared number of inputs (3)."),
          NULL);
    }
    for (i = 0; i < 3 && i < nrhs; ++i) {
        mprhs[i] = prhs[i];
    }
    for (; i < 3; ++i) {
        mprhs[i] = NULL;
    }
    mlfEnterNewContext(0, 3, mprhs[0], mprhs[1], mprhs[2]);
    Mrecarga_2_3_Prunoff_Callback(mprhs[0], mprhs[1], mprhs[2]);
    mlfRestorePreviousContext(0, 3, mprhs[0], mprhs[1], mprhs[2]);
}

/*
 * The function "mlfRecarga_2_3_Precharge_CreateFcn" contains the normal
 * interface for the "recarga_2_3/Precharge_CreateFcn" M-function from file
 * "u:\final_recarga6\recarga\recarga_2_3.m" (lines 302-317). This function
 * processes any input arguments and passes them to the implementation version
 * of the function, appearing above.
 */
static void mlfRecarga_2_3_Precharge_CreateFcn(mxArray * hObject,
                                               mxArray * eventdata,
                                               mxArray * handles) {
    mlfEnterNewContext(0, 3, hObject, eventdata, handles);
    Mrecarga_2_3_Precharge_CreateFcn(hObject, eventdata, handles);
    mlfRestorePreviousContext(0, 3, hObject, eventdata, handles);
}

/*
 * The function "mlxRecarga_2_3_Precharge_CreateFcn" contains the feval
 * interface for the "recarga_2_3/Precharge_CreateFcn" M-function from file
 * "u:\final_recarga6\recarga\recarga_2_3.m" (lines 302-317). The feval
 * function calls the implementation version of recarga_2_3/Precharge_CreateFcn
 * through this function. This function processes any input arguments and
 * passes them to the implementation version of the function, appearing above.
 */
static void mlxRecarga_2_3_Precharge_CreateFcn(int nlhs,
                                               mxArray * plhs[],
                                               int nrhs,
                                               mxArray * prhs[]) {
    mxArray * mprhs[3];
    int i;
    if (nlhs > 0) {
        mlfError(
          mxCreateString(
            "Run-time Error: File: recarga_2_3/Precharge_CreateFcn Line: 30"
            "2 Column: 1 The function \"recarga_2_3/Precharge_CreateFcn\" w"
            "as called with more than the declared number of outputs (0)."),
          NULL);
    }
    if (nrhs > 3) {
        mlfError(
          mxCreateString(
            "Run-time Error: File: recarga_2_3/Precharge_CreateFcn Line: 30"
            "2 Column: 1 The function \"recarga_2_3/Precharge_CreateFcn\" w"
            "as called with more than the declared number of inputs (3)."),
          NULL);
    }
    for (i = 0; i < 3 && i < nrhs; ++i) {
        mprhs[i] = prhs[i];
    }
    for (; i < 3; ++i) {
        mprhs[i] = NULL;
    }
    mlfEnterNewContext(0, 3, mprhs[0], mprhs[1], mprhs[2]);
    Mrecarga_2_3_Precharge_CreateFcn(mprhs[0], mprhs[1], mprhs[2]);
    mlfRestorePreviousContext(0, 3, mprhs[0], mprhs[1], mprhs[2]);
}

/*
 * The function "mlfRecarga_2_3_Precharge_Callback" contains the normal
 * interface for the "recarga_2_3/Precharge_Callback" M-function from file
 * "u:\final_recarga6\recarga\recarga_2_3.m" (lines 317-327). This function
 * processes any input arguments and passes them to the implementation version
 * of the function, appearing above.
 */
static void mlfRecarga_2_3_Precharge_Callback(mxArray * hObject,
                                              mxArray * eventdata,
                                              mxArray * handles) {
    mlfEnterNewContext(0, 3, hObject, eventdata, handles);
    Mrecarga_2_3_Precharge_Callback(hObject, eventdata, handles);
    mlfRestorePreviousContext(0, 3, hObject, eventdata, handles);
}

/*
 * The function "mlxRecarga_2_3_Precharge_Callback" contains the feval
 * interface for the "recarga_2_3/Precharge_Callback" M-function from file
 * "u:\final_recarga6\recarga\recarga_2_3.m" (lines 317-327). The feval
 * function calls the implementation version of recarga_2_3/Precharge_Callback
 * through this function. This function processes any input arguments and
 * passes them to the implementation version of the function, appearing above.
 */
static void mlxRecarga_2_3_Precharge_Callback(int nlhs,
                                              mxArray * plhs[],
                                              int nrhs,
                                              mxArray * prhs[]) {
    mxArray * mprhs[3];
    int i;
    if (nlhs > 0) {
        mlfError(
          mxCreateString(
            "Run-time Error: File: recarga_2_3/Precharge_Callback Line: 317"
            " Column: 1 The function \"recarga_2_3/Precharge_Callback\" was"
            " called with more than the declared number of outputs (0)."),
          NULL);
    }
    if (nrhs > 3) {
        mlfError(
          mxCreateString(
            "Run-time Error: File: recarga_2_3/Precharge_Callback Line: 31"
            "7 Column: 1 The function \"recarga_2_3/Precharge_Callback\" w"
            "as called with more than the declared number of inputs (3)."),
          NULL);
    }
    for (i = 0; i < 3 && i < nrhs; ++i) {
        mprhs[i] = prhs[i];
    }
    for (; i < 3; ++i) {
        mprhs[i] = NULL;
    }
    mlfEnterNewContext(0, 3, mprhs[0], mprhs[1], mprhs[2]);
    Mrecarga_2_3_Precharge_Callback(mprhs[0], mprhs[1], mprhs[2]);
    mlfRestorePreviousContext(0, 3, mprhs[0], mprhs[1], mprhs[2]);
}

/*
 * The function "mlfRecarga_2_3_Pevap_CreateFcn" contains the normal interface
 * for the "recarga_2_3/Pevap_CreateFcn" M-function from file
 * "u:\final_recarga6\recarga\recarga_2_3.m" (lines 327-342). This function
 * processes any input arguments and passes them to the implementation version
 * of the function, appearing above.
 */
static void mlfRecarga_2_3_Pevap_CreateFcn(mxArray * hObject,
                                           mxArray * eventdata,
                                           mxArray * handles) {
    mlfEnterNewContext(0, 3, hObject, eventdata, handles);
    Mrecarga_2_3_Pevap_CreateFcn(hObject, eventdata, handles);
    mlfRestorePreviousContext(0, 3, hObject, eventdata, handles);
}

/*
 * The function "mlxRecarga_2_3_Pevap_CreateFcn" contains the feval interface
 * for the "recarga_2_3/Pevap_CreateFcn" M-function from file
 * "u:\final_recarga6\recarga\recarga_2_3.m" (lines 327-342). The feval
 * function calls the implementation version of recarga_2_3/Pevap_CreateFcn
 * through this function. This function processes any input arguments and
 * passes them to the implementation version of the function, appearing above.
 */
static void mlxRecarga_2_3_Pevap_CreateFcn(int nlhs,
                                           mxArray * plhs[],
                                           int nrhs,
                                           mxArray * prhs[]) {
    mxArray * mprhs[3];
    int i;
    if (nlhs > 0) {
        mlfError(
          mxCreateString(
            "Run-time Error: File: recarga_2_3/Pevap_CreateFcn Line: 327 "
            "Column: 1 The function \"recarga_2_3/Pevap_CreateFcn\" was c"
            "alled with more than the declared number of outputs (0)."),
          NULL);
    }
    if (nrhs > 3) {
        mlfError(
          mxCreateString(
            "Run-time Error: File: recarga_2_3/Pevap_CreateFcn Line: 327"
            " Column: 1 The function \"recarga_2_3/Pevap_CreateFcn\" was"
            " called with more than the declared number of inputs (3)."),
          NULL);
    }
    for (i = 0; i < 3 && i < nrhs; ++i) {
        mprhs[i] = prhs[i];
    }
    for (; i < 3; ++i) {
        mprhs[i] = NULL;
    }
    mlfEnterNewContext(0, 3, mprhs[0], mprhs[1], mprhs[2]);
    Mrecarga_2_3_Pevap_CreateFcn(mprhs[0], mprhs[1], mprhs[2]);
    mlfRestorePreviousContext(0, 3, mprhs[0], mprhs[1], mprhs[2]);
}

/*
 * The function "mlfRecarga_2_3_Pevap_Callback" contains the normal interface
 * for the "recarga_2_3/Pevap_Callback" M-function from file
 * "u:\final_recarga6\recarga\recarga_2_3.m" (lines 342-352). This function
 * processes any input arguments and passes them to the implementation version
 * of the function, appearing above.
 */
static void mlfRecarga_2_3_Pevap_Callback(mxArray * hObject,
                                          mxArray * eventdata,
                                          mxArray * handles) {
    mlfEnterNewContext(0, 3, hObject, eventdata, handles);
    Mrecarga_2_3_Pevap_Callback(hObject, eventdata, handles);
    mlfRestorePreviousContext(0, 3, hObject, eventdata, handles);
}

/*
 * The function "mlxRecarga_2_3_Pevap_Callback" contains the feval interface
 * for the "recarga_2_3/Pevap_Callback" M-function from file
 * "u:\final_recarga6\recarga\recarga_2_3.m" (lines 342-352). The feval
 * function calls the implementation version of recarga_2_3/Pevap_Callback
 * through this function. This function processes any input arguments and
 * passes them to the implementation version of the function, appearing above.
 */
static void mlxRecarga_2_3_Pevap_Callback(int nlhs,
                                          mxArray * plhs[],
                                          int nrhs,
                                          mxArray * prhs[]) {
    mxArray * mprhs[3];
    int i;
    if (nlhs > 0) {
        mlfError(
          mxCreateString(
            "Run-time Error: File: recarga_2_3/Pevap_Callback Line: 342 "
            "Column: 1 The function \"recarga_2_3/Pevap_Callback\" was c"
            "alled with more than the declared number of outputs (0)."),
          NULL);
    }
    if (nrhs > 3) {
        mlfError(
          mxCreateString(
            "Run-time Error: File: recarga_2_3/Pevap_Callback Line: 342 "
            "Column: 1 The function \"recarga_2_3/Pevap_Callback\" was c"
            "alled with more than the declared number of inputs (3)."),
          NULL);
    }
    for (i = 0; i < 3 && i < nrhs; ++i) {
        mprhs[i] = prhs[i];
    }
    for (; i < 3; ++i) {
        mprhs[i] = NULL;
    }
    mlfEnterNewContext(0, 3, mprhs[0], mprhs[1], mprhs[2]);
    Mrecarga_2_3_Pevap_Callback(mprhs[0], mprhs[1], mprhs[2]);
    mlfRestorePreviousContext(0, 3, mprhs[0], mprhs[1], mprhs[2]);
}

/*
 * The function "mlfRecarga_2_3_maxpond_CreateFcn" contains the normal
 * interface for the "recarga_2_3/maxpond_CreateFcn" M-function from file
 * "u:\final_recarga6\recarga\recarga_2_3.m" (lines 352-367). This function
 * processes any input arguments and passes them to the implementation version
 * of the function, appearing above.
 */
static void mlfRecarga_2_3_maxpond_CreateFcn(mxArray * hObject,
                                             mxArray * eventdata,
                                             mxArray * handles) {
    mlfEnterNewContext(0, 3, hObject, eventdata, handles);
    Mrecarga_2_3_maxpond_CreateFcn(hObject, eventdata, handles);
    mlfRestorePreviousContext(0, 3, hObject, eventdata, handles);
}

/*
 * The function "mlxRecarga_2_3_maxpond_CreateFcn" contains the feval interface
 * for the "recarga_2_3/maxpond_CreateFcn" M-function from file
 * "u:\final_recarga6\recarga\recarga_2_3.m" (lines 352-367). The feval
 * function calls the implementation version of recarga_2_3/maxpond_CreateFcn
 * through this function. This function processes any input arguments and
 * passes them to the implementation version of the function, appearing above.
 */
static void mlxRecarga_2_3_maxpond_CreateFcn(int nlhs,
                                             mxArray * plhs[],
                                             int nrhs,
                                             mxArray * prhs[]) {
    mxArray * mprhs[3];
    int i;
    if (nlhs > 0) {
        mlfError(
          mxCreateString(
            "Run-time Error: File: recarga_2_3/maxpond_CreateFcn Line: 352"
            " Column: 1 The function \"recarga_2_3/maxpond_CreateFcn\" was"
            " called with more than the declared number of outputs (0)."),
          NULL);
    }
    if (nrhs > 3) {
        mlfError(
          mxCreateString(
            "Run-time Error: File: recarga_2_3/maxpond_CreateFcn Line: 352"
            " Column: 1 The function \"recarga_2_3/maxpond_CreateFcn\" was"
            " called with more than the declared number of inputs (3)."),
          NULL);
    }
    for (i = 0; i < 3 && i < nrhs; ++i) {
        mprhs[i] = prhs[i];
    }
    for (; i < 3; ++i) {
        mprhs[i] = NULL;
    }
    mlfEnterNewContext(0, 3, mprhs[0], mprhs[1], mprhs[2]);
    Mrecarga_2_3_maxpond_CreateFcn(mprhs[0], mprhs[1], mprhs[2]);
    mlfRestorePreviousContext(0, 3, mprhs[0], mprhs[1], mprhs[2]);
}

/*
 * The function "mlfRecarga_2_3_maxpond_Callback" contains the normal interface
 * for the "recarga_2_3/maxpond_Callback" M-function from file
 * "u:\final_recarga6\recarga\recarga_2_3.m" (lines 367-377). This function
 * processes any input arguments and passes them to the implementation version
 * of the function, appearing above.
 */
static void mlfRecarga_2_3_maxpond_Callback(mxArray * hObject,
                                            mxArray * eventdata,
                                            mxArray * handles) {
    mlfEnterNewContext(0, 3, hObject, eventdata, handles);
    Mrecarga_2_3_maxpond_Callback(hObject, eventdata, handles);
    mlfRestorePreviousContext(0, 3, hObject, eventdata, handles);
}

/*
 * The function "mlxRecarga_2_3_maxpond_Callback" contains the feval interface
 * for the "recarga_2_3/maxpond_Callback" M-function from file
 * "u:\final_recarga6\recarga\recarga_2_3.m" (lines 367-377). The feval
 * function calls the implementation version of recarga_2_3/maxpond_Callback
 * through this function. This function processes any input arguments and
 * passes them to the implementation version of the function, appearing above.
 */
static void mlxRecarga_2_3_maxpond_Callback(int nlhs,
                                            mxArray * plhs[],
                                            int nrhs,
                                            mxArray * prhs[]) {
    mxArray * mprhs[3];
    int i;
    if (nlhs > 0) {
        mlfError(
          mxCreateString(
            "Run-time Error: File: recarga_2_3/maxpond_Callback Line: 367"
            " Column: 1 The function \"recarga_2_3/maxpond_Callback\" was"
            " called with more than the declared number of outputs (0)."),
          NULL);
    }
    if (nrhs > 3) {
        mlfError(
          mxCreateString(
            "Run-time Error: File: recarga_2_3/maxpond_Callback Line: 367"
            " Column: 1 The function \"recarga_2_3/maxpond_Callback\" was"
            " called with more than the declared number of inputs (3)."),
          NULL);
    }
    for (i = 0; i < 3 && i < nrhs; ++i) {
        mprhs[i] = prhs[i];
    }
    for (; i < 3; ++i) {
        mprhs[i] = NULL;
    }
    mlfEnterNewContext(0, 3, mprhs[0], mprhs[1], mprhs[2]);
    Mrecarga_2_3_maxpond_Callback(mprhs[0], mprhs[1], mprhs[2]);
    mlfRestorePreviousContext(0, 3, mprhs[0], mprhs[1], mprhs[2]);
}

/*
 * The function "mlfRecarga_2_3_maxwilt_CreateFcn" contains the normal
 * interface for the "recarga_2_3/maxwilt_CreateFcn" M-function from file
 * "u:\final_recarga6\recarga\recarga_2_3.m" (lines 377-392). This function
 * processes any input arguments and passes them to the implementation version
 * of the function, appearing above.
 */
static void mlfRecarga_2_3_maxwilt_CreateFcn(mxArray * hObject,
                                             mxArray * eventdata,
                                             mxArray * handles) {
    mlfEnterNewContext(0, 3, hObject, eventdata, handles);
    Mrecarga_2_3_maxwilt_CreateFcn(hObject, eventdata, handles);
    mlfRestorePreviousContext(0, 3, hObject, eventdata, handles);
}

/*
 * The function "mlxRecarga_2_3_maxwilt_CreateFcn" contains the feval interface
 * for the "recarga_2_3/maxwilt_CreateFcn" M-function from file
 * "u:\final_recarga6\recarga\recarga_2_3.m" (lines 377-392). The feval
 * function calls the implementation version of recarga_2_3/maxwilt_CreateFcn
 * through this function. This function processes any input arguments and
 * passes them to the implementation version of the function, appearing above.
 */
static void mlxRecarga_2_3_maxwilt_CreateFcn(int nlhs,
                                             mxArray * plhs[],
                                             int nrhs,
                                             mxArray * prhs[]) {
    mxArray * mprhs[3];
    int i;
    if (nlhs > 0) {
        mlfError(
          mxCreateString(
            "Run-time Error: File: recarga_2_3/maxwilt_CreateFcn Line: 377"
            " Column: 1 The function \"recarga_2_3/maxwilt_CreateFcn\" was"
            " called with more than the declared number of outputs (0)."),
          NULL);
    }
    if (nrhs > 3) {
        mlfError(
          mxCreateString(
            "Run-time Error: File: recarga_2_3/maxwilt_CreateFcn Line: 377"
            " Column: 1 The function \"recarga_2_3/maxwilt_CreateFcn\" was"
            " called with more than the declared number of inputs (3)."),
          NULL);
    }
    for (i = 0; i < 3 && i < nrhs; ++i) {
        mprhs[i] = prhs[i];
    }
    for (; i < 3; ++i) {
        mprhs[i] = NULL;
    }
    mlfEnterNewContext(0, 3, mprhs[0], mprhs[1], mprhs[2]);
    Mrecarga_2_3_maxwilt_CreateFcn(mprhs[0], mprhs[1], mprhs[2]);
    mlfRestorePreviousContext(0, 3, mprhs[0], mprhs[1], mprhs[2]);
}

/*
 * The function "mlfRecarga_2_3_maxwilt_Callback" contains the normal interface
 * for the "recarga_2_3/maxwilt_Callback" M-function from file
 * "u:\final_recarga6\recarga\recarga_2_3.m" (lines 392-402). This function
 * processes any input arguments and passes them to the implementation version
 * of the function, appearing above.
 */
static void mlfRecarga_2_3_maxwilt_Callback(mxArray * hObject,
                                            mxArray * eventdata,
                                            mxArray * handles) {
    mlfEnterNewContext(0, 3, hObject, eventdata, handles);
    Mrecarga_2_3_maxwilt_Callback(hObject, eventdata, handles);
    mlfRestorePreviousContext(0, 3, hObject, eventdata, handles);
}

/*
 * The function "mlxRecarga_2_3_maxwilt_Callback" contains the feval interface
 * for the "recarga_2_3/maxwilt_Callback" M-function from file
 * "u:\final_recarga6\recarga\recarga_2_3.m" (lines 392-402). The feval
 * function calls the implementation version of recarga_2_3/maxwilt_Callback
 * through this function. This function processes any input arguments and
 * passes them to the implementation version of the function, appearing above.
 */
static void mlxRecarga_2_3_maxwilt_Callback(int nlhs,
                                            mxArray * plhs[],
                                            int nrhs,
                                            mxArray * prhs[]) {
    mxArray * mprhs[3];
    int i;
    if (nlhs > 0) {
        mlfError(
          mxCreateString(
            "Run-time Error: File: recarga_2_3/maxwilt_Callback Line: 392"
            " Column: 1 The function \"recarga_2_3/maxwilt_Callback\" was"
            " called with more than the declared number of outputs (0)."),
          NULL);
    }
    if (nrhs > 3) {
        mlfError(
          mxCreateString(
            "Run-time Error: File: recarga_2_3/maxwilt_Callback Line: 392"
            " Column: 1 The function \"recarga_2_3/maxwilt_Callback\" was"
            " called with more than the declared number of inputs (3)."),
          NULL);
    }
    for (i = 0; i < 3 && i < nrhs; ++i) {
        mprhs[i] = prhs[i];
    }
    for (; i < 3; ++i) {
        mprhs[i] = NULL;
    }
    mlfEnterNewContext(0, 3, mprhs[0], mprhs[1], mprhs[2]);
    Mrecarga_2_3_maxwilt_Callback(mprhs[0], mprhs[1], mprhs[2]);
    mlfRestorePreviousContext(0, 3, mprhs[0], mprhs[1], mprhs[2]);
}

/*
 * The function "mlfRecarga_2_3_tpond_CreateFcn" contains the normal interface
 * for the "recarga_2_3/tpond_CreateFcn" M-function from file
 * "u:\final_recarga6\recarga\recarga_2_3.m" (lines 402-417). This function
 * processes any input arguments and passes them to the implementation version
 * of the function, appearing above.
 */
static void mlfRecarga_2_3_tpond_CreateFcn(mxArray * hObject,
                                           mxArray * eventdata,
                                           mxArray * handles) {
    mlfEnterNewContext(0, 3, hObject, eventdata, handles);
    Mrecarga_2_3_tpond_CreateFcn(hObject, eventdata, handles);
    mlfRestorePreviousContext(0, 3, hObject, eventdata, handles);
}

/*
 * The function "mlxRecarga_2_3_tpond_CreateFcn" contains the feval interface
 * for the "recarga_2_3/tpond_CreateFcn" M-function from file
 * "u:\final_recarga6\recarga\recarga_2_3.m" (lines 402-417). The feval
 * function calls the implementation version of recarga_2_3/tpond_CreateFcn
 * through this function. This function processes any input arguments and
 * passes them to the implementation version of the function, appearing above.
 */
static void mlxRecarga_2_3_tpond_CreateFcn(int nlhs,
                                           mxArray * plhs[],
                                           int nrhs,
                                           mxArray * prhs[]) {
    mxArray * mprhs[3];
    int i;
    if (nlhs > 0) {
        mlfError(
          mxCreateString(
            "Run-time Error: File: recarga_2_3/tpond_CreateFcn Line: 402 "
            "Column: 1 The function \"recarga_2_3/tpond_CreateFcn\" was c"
            "alled with more than the declared number of outputs (0)."),
          NULL);
    }
    if (nrhs > 3) {
        mlfError(
          mxCreateString(
            "Run-time Error: File: recarga_2_3/tpond_CreateFcn Line: 402"
            " Column: 1 The function \"recarga_2_3/tpond_CreateFcn\" was"
            " called with more than the declared number of inputs (3)."),
          NULL);
    }
    for (i = 0; i < 3 && i < nrhs; ++i) {
        mprhs[i] = prhs[i];
    }
    for (; i < 3; ++i) {
        mprhs[i] = NULL;
    }
    mlfEnterNewContext(0, 3, mprhs[0], mprhs[1], mprhs[2]);
    Mrecarga_2_3_tpond_CreateFcn(mprhs[0], mprhs[1], mprhs[2]);
    mlfRestorePreviousContext(0, 3, mprhs[0], mprhs[1], mprhs[2]);
}

/*
 * The function "mlfRecarga_2_3_tpond_Callback" contains the normal interface
 * for the "recarga_2_3/tpond_Callback" M-function from file
 * "u:\final_recarga6\recarga\recarga_2_3.m" (lines 417-427). This function
 * processes any input arguments and passes them to the implementation version
 * of the function, appearing above.
 */
static void mlfRecarga_2_3_tpond_Callback(mxArray * hObject,
                                          mxArray * eventdata,
                                          mxArray * handles) {
    mlfEnterNewContext(0, 3, hObject, eventdata, handles);
    Mrecarga_2_3_tpond_Callback(hObject, eventdata, handles);
    mlfRestorePreviousContext(0, 3, hObject, eventdata, handles);
}

/*
 * The function "mlxRecarga_2_3_tpond_Callback" contains the feval interface
 * for the "recarga_2_3/tpond_Callback" M-function from file
 * "u:\final_recarga6\recarga\recarga_2_3.m" (lines 417-427). The feval
 * function calls the implementation version of recarga_2_3/tpond_Callback
 * through this function. This function processes any input arguments and
 * passes them to the implementation version of the function, appearing above.
 */
static void mlxRecarga_2_3_tpond_Callback(int nlhs,
                                          mxArray * plhs[],
                                          int nrhs,
                                          mxArray * prhs[]) {
    mxArray * mprhs[3];
    int i;
    if (nlhs > 0) {
        mlfError(
          mxCreateString(
            "Run-time Error: File: recarga_2_3/tpond_Callback Line: 417 "
            "Column: 1 The function \"recarga_2_3/tpond_Callback\" was c"
            "alled with more than the declared number of outputs (0)."),
          NULL);
    }
    if (nrhs > 3) {
        mlfError(
          mxCreateString(
            "Run-time Error: File: recarga_2_3/tpond_Callback Line: 417 "
            "Column: 1 The function \"recarga_2_3/tpond_Callback\" was c"
            "alled with more than the declared number of inputs (3)."),
          NULL);
    }
    for (i = 0; i < 3 && i < nrhs; ++i) {
        mprhs[i] = prhs[i];
    }
    for (; i < 3; ++i) {
        mprhs[i] = NULL;
    }
    mlfEnterNewContext(0, 3, mprhs[0], mprhs[1], mprhs[2]);
    Mrecarga_2_3_tpond_Callback(mprhs[0], mprhs[1], mprhs[2]);
    mlfRestorePreviousContext(0, 3, mprhs[0], mprhs[1], mprhs[2]);
}

/*
 * The function "mlfRecarga_2_3_OFtimes_CreateFcn" contains the normal
 * interface for the "recarga_2_3/OFtimes_CreateFcn" M-function from file
 * "u:\final_recarga6\recarga\recarga_2_3.m" (lines 427-442). This function
 * processes any input arguments and passes them to the implementation version
 * of the function, appearing above.
 */
static void mlfRecarga_2_3_OFtimes_CreateFcn(mxArray * hObject,
                                             mxArray * eventdata,
                                             mxArray * handles) {
    mlfEnterNewContext(0, 3, hObject, eventdata, handles);
    Mrecarga_2_3_OFtimes_CreateFcn(hObject, eventdata, handles);
    mlfRestorePreviousContext(0, 3, hObject, eventdata, handles);
}

/*
 * The function "mlxRecarga_2_3_OFtimes_CreateFcn" contains the feval interface
 * for the "recarga_2_3/OFtimes_CreateFcn" M-function from file
 * "u:\final_recarga6\recarga\recarga_2_3.m" (lines 427-442). The feval
 * function calls the implementation version of recarga_2_3/OFtimes_CreateFcn
 * through this function. This function processes any input arguments and
 * passes them to the implementation version of the function, appearing above.
 */
static void mlxRecarga_2_3_OFtimes_CreateFcn(int nlhs,
                                             mxArray * plhs[],
                                             int nrhs,
                                             mxArray * prhs[]) {
    mxArray * mprhs[3];
    int i;
    if (nlhs > 0) {
        mlfError(
          mxCreateString(
            "Run-time Error: File: recarga_2_3/OFtimes_CreateFcn Line: 427"
            " Column: 1 The function \"recarga_2_3/OFtimes_CreateFcn\" was"
            " called with more than the declared number of outputs (0)."),
          NULL);
    }
    if (nrhs > 3) {
        mlfError(
          mxCreateString(
            "Run-time Error: File: recarga_2_3/OFtimes_CreateFcn Line: 427"
            " Column: 1 The function \"recarga_2_3/OFtimes_CreateFcn\" was"
            " called with more than the declared number of inputs (3)."),
          NULL);
    }
    for (i = 0; i < 3 && i < nrhs; ++i) {
        mprhs[i] = prhs[i];
    }
    for (; i < 3; ++i) {
        mprhs[i] = NULL;
    }
    mlfEnterNewContext(0, 3, mprhs[0], mprhs[1], mprhs[2]);
    Mrecarga_2_3_OFtimes_CreateFcn(mprhs[0], mprhs[1], mprhs[2]);
    mlfRestorePreviousContext(0, 3, mprhs[0], mprhs[1], mprhs[2]);
}

/*
 * The function "mlfRecarga_2_3_OFtimes_Callback" contains the normal interface
 * for the "recarga_2_3/OFtimes_Callback" M-function from file
 * "u:\final_recarga6\recarga\recarga_2_3.m" (lines 442-452). This function
 * processes any input arguments and passes them to the implementation version
 * of the function, appearing above.
 */
static void mlfRecarga_2_3_OFtimes_Callback(mxArray * hObject,
                                            mxArray * eventdata,
                                            mxArray * handles) {
    mlfEnterNewContext(0, 3, hObject, eventdata, handles);
    Mrecarga_2_3_OFtimes_Callback(hObject, eventdata, handles);
    mlfRestorePreviousContext(0, 3, hObject, eventdata, handles);
}

/*
 * The function "mlxRecarga_2_3_OFtimes_Callback" contains the feval interface
 * for the "recarga_2_3/OFtimes_Callback" M-function from file
 * "u:\final_recarga6\recarga\recarga_2_3.m" (lines 442-452). The feval
 * function calls the implementation version of recarga_2_3/OFtimes_Callback
 * through this function. This function processes any input arguments and
 * passes them to the implementation version of the function, appearing above.
 */
static void mlxRecarga_2_3_OFtimes_Callback(int nlhs,
                                            mxArray * plhs[],
                                            int nrhs,
                                            mxArray * prhs[]) {
    mxArray * mprhs[3];
    int i;
    if (nlhs > 0) {
        mlfError(
          mxCreateString(
            "Run-time Error: File: recarga_2_3/OFtimes_Callback Line: 442"
            " Column: 1 The function \"recarga_2_3/OFtimes_Callback\" was"
            " called with more than the declared number of outputs (0)."),
          NULL);
    }
    if (nrhs > 3) {
        mlfError(
          mxCreateString(
            "Run-time Error: File: recarga_2_3/OFtimes_Callback Line: 442"
            " Column: 1 The function \"recarga_2_3/OFtimes_Callback\" was"
            " called with more than the declared number of inputs (3)."),
          NULL);
    }
    for (i = 0; i < 3 && i < nrhs; ++i) {
        mprhs[i] = prhs[i];
    }
    for (; i < 3; ++i) {
        mprhs[i] = NULL;
    }
    mlfEnterNewContext(0, 3, mprhs[0], mprhs[1], mprhs[2]);
    Mrecarga_2_3_OFtimes_Callback(mprhs[0], mprhs[1], mprhs[2]);
    mlfRestorePreviousContext(0, 3, mprhs[0], mprhs[1], mprhs[2]);
}

/*
 * The function "mlfRecarga_2_3_ImpA_CreateFcn" contains the normal interface
 * for the "recarga_2_3/ImpA_CreateFcn" M-function from file
 * "u:\final_recarga6\recarga\recarga_2_3.m" (lines 452-467). This function
 * processes any input arguments and passes them to the implementation version
 * of the function, appearing above.
 */
static void mlfRecarga_2_3_ImpA_CreateFcn(mxArray * hObject,
                                          mxArray * eventdata,
                                          mxArray * handles) {
    mlfEnterNewContext(0, 3, hObject, eventdata, handles);
    Mrecarga_2_3_ImpA_CreateFcn(hObject, eventdata, handles);
    mlfRestorePreviousContext(0, 3, hObject, eventdata, handles);
}

/*
 * The function "mlxRecarga_2_3_ImpA_CreateFcn" contains the feval interface
 * for the "recarga_2_3/ImpA_CreateFcn" M-function from file
 * "u:\final_recarga6\recarga\recarga_2_3.m" (lines 452-467). The feval
 * function calls the implementation version of recarga_2_3/ImpA_CreateFcn
 * through this function. This function processes any input arguments and
 * passes them to the implementation version of the function, appearing above.
 */
static void mlxRecarga_2_3_ImpA_CreateFcn(int nlhs,
                                          mxArray * plhs[],
                                          int nrhs,
                                          mxArray * prhs[]) {
    mxArray * mprhs[3];
    int i;
    if (nlhs > 0) {
        mlfError(
          mxCreateString(
            "Run-time Error: File: recarga_2_3/ImpA_CreateFcn Line: 452 "
            "Column: 1 The function \"recarga_2_3/ImpA_CreateFcn\" was c"
            "alled with more than the declared number of outputs (0)."),
          NULL);
    }
    if (nrhs > 3) {
        mlfError(
          mxCreateString(
            "Run-time Error: File: recarga_2_3/ImpA_CreateFcn Line: 452 "
            "Column: 1 The function \"recarga_2_3/ImpA_CreateFcn\" was c"
            "alled with more than the declared number of inputs (3)."),
          NULL);
    }
    for (i = 0; i < 3 && i < nrhs; ++i) {
        mprhs[i] = prhs[i];
    }
    for (; i < 3; ++i) {
        mprhs[i] = NULL;
    }
    mlfEnterNewContext(0, 3, mprhs[0], mprhs[1], mprhs[2]);
    Mrecarga_2_3_ImpA_CreateFcn(mprhs[0], mprhs[1], mprhs[2]);
    mlfRestorePreviousContext(0, 3, mprhs[0], mprhs[1], mprhs[2]);
}

/*
 * The function "mlfRecarga_2_3_ImpA_Callback" contains the normal interface
 * for the "recarga_2_3/ImpA_Callback" M-function from file
 * "u:\final_recarga6\recarga\recarga_2_3.m" (lines 467-477). This function
 * processes any input arguments and passes them to the implementation version
 * of the function, appearing above.
 */
static void mlfRecarga_2_3_ImpA_Callback(mxArray * hObject,
                                         mxArray * eventdata,
                                         mxArray * handles) {
    mlfEnterNewContext(0, 3, hObject, eventdata, handles);
    Mrecarga_2_3_ImpA_Callback(hObject, eventdata, handles);
    mlfRestorePreviousContext(0, 3, hObject, eventdata, handles);
}

/*
 * The function "mlxRecarga_2_3_ImpA_Callback" contains the feval interface for
 * the "recarga_2_3/ImpA_Callback" M-function from file
 * "u:\final_recarga6\recarga\recarga_2_3.m" (lines 467-477). The feval
 * function calls the implementation version of recarga_2_3/ImpA_Callback
 * through this function. This function processes any input arguments and
 * passes them to the implementation version of the function, appearing above.
 */
static void mlxRecarga_2_3_ImpA_Callback(int nlhs,
                                         mxArray * plhs[],
                                         int nrhs,
                                         mxArray * prhs[]) {
    mxArray * mprhs[3];
    int i;
    if (nlhs > 0) {
        mlfError(
          mxCreateString(
            "Run-time Error: File: recarga_2_3/ImpA_Callback Line: 467 "
            "Column: 1 The function \"recarga_2_3/ImpA_Callback\" was c"
            "alled with more than the declared number of outputs (0)."),
          NULL);
    }
    if (nrhs > 3) {
        mlfError(
          mxCreateString(
            "Run-time Error: File: recarga_2_3/ImpA_Callback Line: 467 "
            "Column: 1 The function \"recarga_2_3/ImpA_Callback\" was c"
            "alled with more than the declared number of inputs (3)."),
          NULL);
    }
    for (i = 0; i < 3 && i < nrhs; ++i) {
        mprhs[i] = prhs[i];
    }
    for (; i < 3; ++i) {
        mprhs[i] = NULL;
    }
    mlfEnterNewContext(0, 3, mprhs[0], mprhs[1], mprhs[2]);
    Mrecarga_2_3_ImpA_Callback(mprhs[0], mprhs[1], mprhs[2]);
    mlfRestorePreviousContext(0, 3, mprhs[0], mprhs[1], mprhs[2]);
}

/*
 * The function "mlfRecarga_2_3_CN_CreateFcn" contains the normal interface for
 * the "recarga_2_3/CN_CreateFcn" M-function from file
 * "u:\final_recarga6\recarga\recarga_2_3.m" (lines 477-492). This function
 * processes any input arguments and passes them to the implementation version
 * of the function, appearing above.
 */
static void mlfRecarga_2_3_CN_CreateFcn(mxArray * hObject,
                                        mxArray * eventdata,
                                        mxArray * handles) {
    mlfEnterNewContext(0, 3, hObject, eventdata, handles);
    Mrecarga_2_3_CN_CreateFcn(hObject, eventdata, handles);
    mlfRestorePreviousContext(0, 3, hObject, eventdata, handles);
}

/*
 * The function "mlxRecarga_2_3_CN_CreateFcn" contains the feval interface for
 * the "recarga_2_3/CN_CreateFcn" M-function from file
 * "u:\final_recarga6\recarga\recarga_2_3.m" (lines 477-492). The feval
 * function calls the implementation version of recarga_2_3/CN_CreateFcn
 * through this function. This function processes any input arguments and
 * passes them to the implementation version of the function, appearing above.
 */
static void mlxRecarga_2_3_CN_CreateFcn(int nlhs,
                                        mxArray * plhs[],
                                        int nrhs,
                                        mxArray * prhs[]) {
    mxArray * mprhs[3];
    int i;
    if (nlhs > 0) {
        mlfError(
          mxCreateString(
            "Run-time Error: File: recarga_2_3/CN_CreateFcn Line: 477 C"
            "olumn: 1 The function \"recarga_2_3/CN_CreateFcn\" was cal"
            "led with more than the declared number of outputs (0)."),
          NULL);
    }
    if (nrhs > 3) {
        mlfError(
          mxCreateString(
            "Run-time Error: File: recarga_2_3/CN_CreateFcn Line: 477 "
            "Column: 1 The function \"recarga_2_3/CN_CreateFcn\" was c"
            "alled with more than the declared number of inputs (3)."),
          NULL);
    }
    for (i = 0; i < 3 && i < nrhs; ++i) {
        mprhs[i] = prhs[i];
    }
    for (; i < 3; ++i) {
        mprhs[i] = NULL;
    }
    mlfEnterNewContext(0, 3, mprhs[0], mprhs[1], mprhs[2]);
    Mrecarga_2_3_CN_CreateFcn(mprhs[0], mprhs[1], mprhs[2]);
    mlfRestorePreviousContext(0, 3, mprhs[0], mprhs[1], mprhs[2]);
}

/*
 * The function "mlfRecarga_2_3_CN_Callback" contains the normal interface for
 * the "recarga_2_3/CN_Callback" M-function from file
 * "u:\final_recarga6\recarga\recarga_2_3.m" (lines 492-502). This function
 * processes any input arguments and passes them to the implementation version
 * of the function, appearing above.
 */
static void mlfRecarga_2_3_CN_Callback(mxArray * hObject,
                                       mxArray * eventdata,
                                       mxArray * handles) {
    mlfEnterNewContext(0, 3, hObject, eventdata, handles);
    Mrecarga_2_3_CN_Callback(hObject, eventdata, handles);
    mlfRestorePreviousContext(0, 3, hObject, eventdata, handles);
}

/*
 * The function "mlxRecarga_2_3_CN_Callback" contains the feval interface for
 * the "recarga_2_3/CN_Callback" M-function from file
 * "u:\final_recarga6\recarga\recarga_2_3.m" (lines 492-502). The feval
 * function calls the implementation version of recarga_2_3/CN_Callback through
 * this function. This function processes any input arguments and passes them
 * to the implementation version of the function, appearing above.
 */
static void mlxRecarga_2_3_CN_Callback(int nlhs,
                                       mxArray * plhs[],
                                       int nrhs,
                                       mxArray * prhs[]) {
    mxArray * mprhs[3];
    int i;
    if (nlhs > 0) {
        mlfError(
          mxCreateString(
            "Run-time Error: File: recarga_2_3/CN_Callback Line: 492 C"
            "olumn: 1 The function \"recarga_2_3/CN_Callback\" was cal"
            "led with more than the declared number of outputs (0)."),
          NULL);
    }
    if (nrhs > 3) {
        mlfError(
          mxCreateString(
            "Run-time Error: File: recarga_2_3/CN_Callback Line: 492 C"
            "olumn: 1 The function \"recarga_2_3/CN_Callback\" was cal"
            "led with more than the declared number of inputs (3)."),
          NULL);
    }
    for (i = 0; i < 3 && i < nrhs; ++i) {
        mprhs[i] = prhs[i];
    }
    for (; i < 3; ++i) {
        mprhs[i] = NULL;
    }
    mlfEnterNewContext(0, 3, mprhs[0], mprhs[1], mprhs[2]);
    Mrecarga_2_3_CN_Callback(mprhs[0], mprhs[1], mprhs[2]);
    mlfRestorePreviousContext(0, 3, mprhs[0], mprhs[1], mprhs[2]);
}

/*
 * The function "mlfRecarga_2_3_ImpVol_CreateFcn" contains the normal interface
 * for the "recarga_2_3/ImpVol_CreateFcn" M-function from file
 * "u:\final_recarga6\recarga\recarga_2_3.m" (lines 502-517). This function
 * processes any input arguments and passes them to the implementation version
 * of the function, appearing above.
 */
static void mlfRecarga_2_3_ImpVol_CreateFcn(mxArray * hObject,
                                            mxArray * eventdata,
                                            mxArray * handles) {
    mlfEnterNewContext(0, 3, hObject, eventdata, handles);
    Mrecarga_2_3_ImpVol_CreateFcn(hObject, eventdata, handles);
    mlfRestorePreviousContext(0, 3, hObject, eventdata, handles);
}

/*
 * The function "mlxRecarga_2_3_ImpVol_CreateFcn" contains the feval interface
 * for the "recarga_2_3/ImpVol_CreateFcn" M-function from file
 * "u:\final_recarga6\recarga\recarga_2_3.m" (lines 502-517). The feval
 * function calls the implementation version of recarga_2_3/ImpVol_CreateFcn
 * through this function. This function processes any input arguments and
 * passes them to the implementation version of the function, appearing above.
 */
static void mlxRecarga_2_3_ImpVol_CreateFcn(int nlhs,
                                            mxArray * plhs[],
                                            int nrhs,
                                            mxArray * prhs[]) {
    mxArray * mprhs[3];
    int i;
    if (nlhs > 0) {
        mlfError(
          mxCreateString(
            "Run-time Error: File: recarga_2_3/ImpVol_CreateFcn Line: 502"
            " Column: 1 The function \"recarga_2_3/ImpVol_CreateFcn\" was"
            " called with more than the declared number of outputs (0)."),
          NULL);
    }
    if (nrhs > 3) {
        mlfError(
          mxCreateString(
            "Run-time Error: File: recarga_2_3/ImpVol_CreateFcn Line: 502"
            " Column: 1 The function \"recarga_2_3/ImpVol_CreateFcn\" was"
            " called with more than the declared number of inputs (3)."),
          NULL);
    }
    for (i = 0; i < 3 && i < nrhs; ++i) {
        mprhs[i] = prhs[i];
    }
    for (; i < 3; ++i) {
        mprhs[i] = NULL;
    }
    mlfEnterNewContext(0, 3, mprhs[0], mprhs[1], mprhs[2]);
    Mrecarga_2_3_ImpVol_CreateFcn(mprhs[0], mprhs[1], mprhs[2]);
    mlfRestorePreviousContext(0, 3, mprhs[0], mprhs[1], mprhs[2]);
}

/*
 * The function "mlfRecarga_2_3_ImpVol_Callback" contains the normal interface
 * for the "recarga_2_3/ImpVol_Callback" M-function from file
 * "u:\final_recarga6\recarga\recarga_2_3.m" (lines 517-527). This function
 * processes any input arguments and passes them to the implementation version
 * of the function, appearing above.
 */
static void mlfRecarga_2_3_ImpVol_Callback(mxArray * hObject,
                                           mxArray * eventdata,
                                           mxArray * handles) {
    mlfEnterNewContext(0, 3, hObject, eventdata, handles);
    Mrecarga_2_3_ImpVol_Callback(hObject, eventdata, handles);
    mlfRestorePreviousContext(0, 3, hObject, eventdata, handles);
}

/*
 * The function "mlxRecarga_2_3_ImpVol_Callback" contains the feval interface
 * for the "recarga_2_3/ImpVol_Callback" M-function from file
 * "u:\final_recarga6\recarga\recarga_2_3.m" (lines 517-527). The feval
 * function calls the implementation version of recarga_2_3/ImpVol_Callback
 * through this function. This function processes any input arguments and
 * passes them to the implementation version of the function, appearing above.
 */
static void mlxRecarga_2_3_ImpVol_Callback(int nlhs,
                                           mxArray * plhs[],
                                           int nrhs,
                                           mxArray * prhs[]) {
    mxArray * mprhs[3];
    int i;
    if (nlhs > 0) {
        mlfError(
          mxCreateString(
            "Run-time Error: File: recarga_2_3/ImpVol_Callback Line: 517 "
            "Column: 1 The function \"recarga_2_3/ImpVol_Callback\" was c"
            "alled with more than the declared number of outputs (0)."),
          NULL);
    }
    if (nrhs > 3) {
        mlfError(
          mxCreateString(
            "Run-time Error: File: recarga_2_3/ImpVol_Callback Line: 517"
            " Column: 1 The function \"recarga_2_3/ImpVol_Callback\" was"
            " called with more than the declared number of inputs (3)."),
          NULL);
    }
    for (i = 0; i < 3 && i < nrhs; ++i) {
        mprhs[i] = prhs[i];
    }
    for (; i < 3; ++i) {
        mprhs[i] = NULL;
    }
    mlfEnterNewContext(0, 3, mprhs[0], mprhs[1], mprhs[2]);
    Mrecarga_2_3_ImpVol_Callback(mprhs[0], mprhs[1], mprhs[2]);
    mlfRestorePreviousContext(0, 3, mprhs[0], mprhs[1], mprhs[2]);
}

/*
 * The function "mlfRecarga_2_3_PervVol_CreateFcn" contains the normal
 * interface for the "recarga_2_3/PervVol_CreateFcn" M-function from file
 * "u:\final_recarga6\recarga\recarga_2_3.m" (lines 527-542). This function
 * processes any input arguments and passes them to the implementation version
 * of the function, appearing above.
 */
static void mlfRecarga_2_3_PervVol_CreateFcn(mxArray * hObject,
                                             mxArray * eventdata,
                                             mxArray * handles) {
    mlfEnterNewContext(0, 3, hObject, eventdata, handles);
    Mrecarga_2_3_PervVol_CreateFcn(hObject, eventdata, handles);
    mlfRestorePreviousContext(0, 3, hObject, eventdata, handles);
}

/*
 * The function "mlxRecarga_2_3_PervVol_CreateFcn" contains the feval interface
 * for the "recarga_2_3/PervVol_CreateFcn" M-function from file
 * "u:\final_recarga6\recarga\recarga_2_3.m" (lines 527-542). The feval
 * function calls the implementation version of recarga_2_3/PervVol_CreateFcn
 * through this function. This function processes any input arguments and
 * passes them to the implementation version of the function, appearing above.
 */
static void mlxRecarga_2_3_PervVol_CreateFcn(int nlhs,
                                             mxArray * plhs[],
                                             int nrhs,
                                             mxArray * prhs[]) {
    mxArray * mprhs[3];
    int i;
    if (nlhs > 0) {
        mlfError(
          mxCreateString(
            "Run-time Error: File: recarga_2_3/PervVol_CreateFcn Line: 527"
            " Column: 1 The function \"recarga_2_3/PervVol_CreateFcn\" was"
            " called with more than the declared number of outputs (0)."),
          NULL);
    }
    if (nrhs > 3) {
        mlfError(
          mxCreateString(
            "Run-time Error: File: recarga_2_3/PervVol_CreateFcn Line: 527"
            " Column: 1 The function \"recarga_2_3/PervVol_CreateFcn\" was"
            " called with more than the declared number of inputs (3)."),
          NULL);
    }
    for (i = 0; i < 3 && i < nrhs; ++i) {
        mprhs[i] = prhs[i];
    }
    for (; i < 3; ++i) {
        mprhs[i] = NULL;
    }
    mlfEnterNewContext(0, 3, mprhs[0], mprhs[1], mprhs[2]);
    Mrecarga_2_3_PervVol_CreateFcn(mprhs[0], mprhs[1], mprhs[2]);
    mlfRestorePreviousContext(0, 3, mprhs[0], mprhs[1], mprhs[2]);
}

/*
 * The function "mlfRecarga_2_3_PervVol_Callback" contains the normal interface
 * for the "recarga_2_3/PervVol_Callback" M-function from file
 * "u:\final_recarga6\recarga\recarga_2_3.m" (lines 542-552). This function
 * processes any input arguments and passes them to the implementation version
 * of the function, appearing above.
 */
static void mlfRecarga_2_3_PervVol_Callback(mxArray * hObject,
                                            mxArray * eventdata,
                                            mxArray * handles) {
    mlfEnterNewContext(0, 3, hObject, eventdata, handles);
    Mrecarga_2_3_PervVol_Callback(hObject, eventdata, handles);
    mlfRestorePreviousContext(0, 3, hObject, eventdata, handles);
}

/*
 * The function "mlxRecarga_2_3_PervVol_Callback" contains the feval interface
 * for the "recarga_2_3/PervVol_Callback" M-function from file
 * "u:\final_recarga6\recarga\recarga_2_3.m" (lines 542-552). The feval
 * function calls the implementation version of recarga_2_3/PervVol_Callback
 * through this function. This function processes any input arguments and
 * passes them to the implementation version of the function, appearing above.
 */
static void mlxRecarga_2_3_PervVol_Callback(int nlhs,
                                            mxArray * plhs[],
                                            int nrhs,
                                            mxArray * prhs[]) {
    mxArray * mprhs[3];
    int i;
    if (nlhs > 0) {
        mlfError(
          mxCreateString(
            "Run-time Error: File: recarga_2_3/PervVol_Callback Line: 542"
            " Column: 1 The function \"recarga_2_3/PervVol_Callback\" was"
            " called with more than the declared number of outputs (0)."),
          NULL);
    }
    if (nrhs > 3) {
        mlfError(
          mxCreateString(
            "Run-time Error: File: recarga_2_3/PervVol_Callback Line: 542"
            " Column: 1 The function \"recarga_2_3/PervVol_Callback\" was"
            " called with more than the declared number of inputs (3)."),
          NULL);
    }
    for (i = 0; i < 3 && i < nrhs; ++i) {
        mprhs[i] = prhs[i];
    }
    for (; i < 3; ++i) {
        mprhs[i] = NULL;
    }
    mlfEnterNewContext(0, 3, mprhs[0], mprhs[1], mprhs[2]);
    Mrecarga_2_3_PervVol_Callback(mprhs[0], mprhs[1], mprhs[2]);
    mlfRestorePreviousContext(0, 3, mprhs[0], mprhs[1], mprhs[2]);
}

/*
 * The function "mlfRecarga_2_3_ImpDpth_CreateFcn" contains the normal
 * interface for the "recarga_2_3/ImpDpth_CreateFcn" M-function from file
 * "u:\final_recarga6\recarga\recarga_2_3.m" (lines 552-567). This function
 * processes any input arguments and passes them to the implementation version
 * of the function, appearing above.
 */
static void mlfRecarga_2_3_ImpDpth_CreateFcn(mxArray * hObject,
                                             mxArray * eventdata,
                                             mxArray * handles) {
    mlfEnterNewContext(0, 3, hObject, eventdata, handles);
    Mrecarga_2_3_ImpDpth_CreateFcn(hObject, eventdata, handles);
    mlfRestorePreviousContext(0, 3, hObject, eventdata, handles);
}

/*
 * The function "mlxRecarga_2_3_ImpDpth_CreateFcn" contains the feval interface
 * for the "recarga_2_3/ImpDpth_CreateFcn" M-function from file
 * "u:\final_recarga6\recarga\recarga_2_3.m" (lines 552-567). The feval
 * function calls the implementation version of recarga_2_3/ImpDpth_CreateFcn
 * through this function. This function processes any input arguments and
 * passes them to the implementation version of the function, appearing above.
 */
static void mlxRecarga_2_3_ImpDpth_CreateFcn(int nlhs,
                                             mxArray * plhs[],
                                             int nrhs,
                                             mxArray * prhs[]) {
    mxArray * mprhs[3];
    int i;
    if (nlhs > 0) {
        mlfError(
          mxCreateString(
            "Run-time Error: File: recarga_2_3/ImpDpth_CreateFcn Line: 552"
            " Column: 1 The function \"recarga_2_3/ImpDpth_CreateFcn\" was"
            " called with more than the declared number of outputs (0)."),
          NULL);
    }
    if (nrhs > 3) {
        mlfError(
          mxCreateString(
            "Run-time Error: File: recarga_2_3/ImpDpth_CreateFcn Line: 552"
            " Column: 1 The function \"recarga_2_3/ImpDpth_CreateFcn\" was"
            " called with more than the declared number of inputs (3)."),
          NULL);
    }
    for (i = 0; i < 3 && i < nrhs; ++i) {
        mprhs[i] = prhs[i];
    }
    for (; i < 3; ++i) {
        mprhs[i] = NULL;
    }
    mlfEnterNewContext(0, 3, mprhs[0], mprhs[1], mprhs[2]);
    Mrecarga_2_3_ImpDpth_CreateFcn(mprhs[0], mprhs[1], mprhs[2]);
    mlfRestorePreviousContext(0, 3, mprhs[0], mprhs[1], mprhs[2]);
}

/*
 * The function "mlfRecarga_2_3_ImpDpth_Callback" contains the normal interface
 * for the "recarga_2_3/ImpDpth_Callback" M-function from file
 * "u:\final_recarga6\recarga\recarga_2_3.m" (lines 567-577). This function
 * processes any input arguments and passes them to the implementation version
 * of the function, appearing above.
 */
static void mlfRecarga_2_3_ImpDpth_Callback(mxArray * hObject,
                                            mxArray * eventdata,
                                            mxArray * handles) {
    mlfEnterNewContext(0, 3, hObject, eventdata, handles);
    Mrecarga_2_3_ImpDpth_Callback(hObject, eventdata, handles);
    mlfRestorePreviousContext(0, 3, hObject, eventdata, handles);
}

/*
 * The function "mlxRecarga_2_3_ImpDpth_Callback" contains the feval interface
 * for the "recarga_2_3/ImpDpth_Callback" M-function from file
 * "u:\final_recarga6\recarga\recarga_2_3.m" (lines 567-577). The feval
 * function calls the implementation version of recarga_2_3/ImpDpth_Callback
 * through this function. This function processes any input arguments and
 * passes them to the implementation version of the function, appearing above.
 */
static void mlxRecarga_2_3_ImpDpth_Callback(int nlhs,
                                            mxArray * plhs[],
                                            int nrhs,
                                            mxArray * prhs[]) {
    mxArray * mprhs[3];
    int i;
    if (nlhs > 0) {
        mlfError(
          mxCreateString(
            "Run-time Error: File: recarga_2_3/ImpDpth_Callback Line: 567"
            " Column: 1 The function \"recarga_2_3/ImpDpth_Callback\" was"
            " called with more than the declared number of outputs (0)."),
          NULL);
    }
    if (nrhs > 3) {
        mlfError(
          mxCreateString(
            "Run-time Error: File: recarga_2_3/ImpDpth_Callback Line: 567"
            " Column: 1 The function \"recarga_2_3/ImpDpth_Callback\" was"
            " called with more than the declared number of inputs (3)."),
          NULL);
    }
    for (i = 0; i < 3 && i < nrhs; ++i) {
        mprhs[i] = prhs[i];
    }
    for (; i < 3; ++i) {
        mprhs[i] = NULL;
    }
    mlfEnterNewContext(0, 3, mprhs[0], mprhs[1], mprhs[2]);
    Mrecarga_2_3_ImpDpth_Callback(mprhs[0], mprhs[1], mprhs[2]);
    mlfRestorePreviousContext(0, 3, mprhs[0], mprhs[1], mprhs[2]);
}

/*
 * The function "mlfRecarga_2_3_PervDpth_CreateFcn" contains the normal
 * interface for the "recarga_2_3/PervDpth_CreateFcn" M-function from file
 * "u:\final_recarga6\recarga\recarga_2_3.m" (lines 577-592). This function
 * processes any input arguments and passes them to the implementation version
 * of the function, appearing above.
 */
static void mlfRecarga_2_3_PervDpth_CreateFcn(mxArray * hObject,
                                              mxArray * eventdata,
                                              mxArray * handles) {
    mlfEnterNewContext(0, 3, hObject, eventdata, handles);
    Mrecarga_2_3_PervDpth_CreateFcn(hObject, eventdata, handles);
    mlfRestorePreviousContext(0, 3, hObject, eventdata, handles);
}

/*
 * The function "mlxRecarga_2_3_PervDpth_CreateFcn" contains the feval
 * interface for the "recarga_2_3/PervDpth_CreateFcn" M-function from file
 * "u:\final_recarga6\recarga\recarga_2_3.m" (lines 577-592). The feval
 * function calls the implementation version of recarga_2_3/PervDpth_CreateFcn
 * through this function. This function processes any input arguments and
 * passes them to the implementation version of the function, appearing above.
 */
static void mlxRecarga_2_3_PervDpth_CreateFcn(int nlhs,
                                              mxArray * plhs[],
                                              int nrhs,
                                              mxArray * prhs[]) {
    mxArray * mprhs[3];
    int i;
    if (nlhs > 0) {
        mlfError(
          mxCreateString(
            "Run-time Error: File: recarga_2_3/PervDpth_CreateFcn Line: 577"
            " Column: 1 The function \"recarga_2_3/PervDpth_CreateFcn\" was"
            " called with more than the declared number of outputs (0)."),
          NULL);
    }
    if (nrhs > 3) {
        mlfError(
          mxCreateString(
            "Run-time Error: File: recarga_2_3/PervDpth_CreateFcn Line: 57"
            "7 Column: 1 The function \"recarga_2_3/PervDpth_CreateFcn\" w"
            "as called with more than the declared number of inputs (3)."),
          NULL);
    }
    for (i = 0; i < 3 && i < nrhs; ++i) {
        mprhs[i] = prhs[i];
    }
    for (; i < 3; ++i) {
        mprhs[i] = NULL;
    }
    mlfEnterNewContext(0, 3, mprhs[0], mprhs[1], mprhs[2]);
    Mrecarga_2_3_PervDpth_CreateFcn(mprhs[0], mprhs[1], mprhs[2]);
    mlfRestorePreviousContext(0, 3, mprhs[0], mprhs[1], mprhs[2]);
}

/*
 * The function "mlfRecarga_2_3_PervDpth_Callback" contains the normal
 * interface for the "recarga_2_3/PervDpth_Callback" M-function from file
 * "u:\final_recarga6\recarga\recarga_2_3.m" (lines 592-602). This function
 * processes any input arguments and passes them to the implementation version
 * of the function, appearing above.
 */
static void mlfRecarga_2_3_PervDpth_Callback(mxArray * hObject,
                                             mxArray * eventdata,
                                             mxArray * handles) {
    mlfEnterNewContext(0, 3, hObject, eventdata, handles);
    Mrecarga_2_3_PervDpth_Callback(hObject, eventdata, handles);
    mlfRestorePreviousContext(0, 3, hObject, eventdata, handles);
}

/*
 * The function "mlxRecarga_2_3_PervDpth_Callback" contains the feval interface
 * for the "recarga_2_3/PervDpth_Callback" M-function from file
 * "u:\final_recarga6\recarga\recarga_2_3.m" (lines 592-602). The feval
 * function calls the implementation version of recarga_2_3/PervDpth_Callback
 * through this function. This function processes any input arguments and
 * passes them to the implementation version of the function, appearing above.
 */
static void mlxRecarga_2_3_PervDpth_Callback(int nlhs,
                                             mxArray * plhs[],
                                             int nrhs,
                                             mxArray * prhs[]) {
    mxArray * mprhs[3];
    int i;
    if (nlhs > 0) {
        mlfError(
          mxCreateString(
            "Run-time Error: File: recarga_2_3/PervDpth_Callback Line: 592"
            " Column: 1 The function \"recarga_2_3/PervDpth_Callback\" was"
            " called with more than the declared number of outputs (0)."),
          NULL);
    }
    if (nrhs > 3) {
        mlfError(
          mxCreateString(
            "Run-time Error: File: recarga_2_3/PervDpth_Callback Line: 592"
            " Column: 1 The function \"recarga_2_3/PervDpth_Callback\" was"
            " called with more than the declared number of inputs (3)."),
          NULL);
    }
    for (i = 0; i < 3 && i < nrhs; ++i) {
        mprhs[i] = prhs[i];
    }
    for (; i < 3; ++i) {
        mprhs[i] = NULL;
    }
    mlfEnterNewContext(0, 3, mprhs[0], mprhs[1], mprhs[2]);
    Mrecarga_2_3_PervDpth_Callback(mprhs[0], mprhs[1], mprhs[2]);
    mlfRestorePreviousContext(0, 3, mprhs[0], mprhs[1], mprhs[2]);
}

/*
 * The function "mlfRecarga_2_3_RoffDpth_CreateFcn" contains the normal
 * interface for the "recarga_2_3/RoffDpth_CreateFcn" M-function from file
 * "u:\final_recarga6\recarga\recarga_2_3.m" (lines 602-617). This function
 * processes any input arguments and passes them to the implementation version
 * of the function, appearing above.
 */
static void mlfRecarga_2_3_RoffDpth_CreateFcn(mxArray * hObject,
                                              mxArray * eventdata,
                                              mxArray * handles) {
    mlfEnterNewContext(0, 3, hObject, eventdata, handles);
    Mrecarga_2_3_RoffDpth_CreateFcn(hObject, eventdata, handles);
    mlfRestorePreviousContext(0, 3, hObject, eventdata, handles);
}

/*
 * The function "mlxRecarga_2_3_RoffDpth_CreateFcn" contains the feval
 * interface for the "recarga_2_3/RoffDpth_CreateFcn" M-function from file
 * "u:\final_recarga6\recarga\recarga_2_3.m" (lines 602-617). The feval
 * function calls the implementation version of recarga_2_3/RoffDpth_CreateFcn
 * through this function. This function processes any input arguments and
 * passes them to the implementation version of the function, appearing above.
 */
static void mlxRecarga_2_3_RoffDpth_CreateFcn(int nlhs,
                                              mxArray * plhs[],
                                              int nrhs,
                                              mxArray * prhs[]) {
    mxArray * mprhs[3];
    int i;
    if (nlhs > 0) {
        mlfError(
          mxCreateString(
            "Run-time Error: File: recarga_2_3/RoffDpth_CreateFcn Line: 602"
            " Column: 1 The function \"recarga_2_3/RoffDpth_CreateFcn\" was"
            " called with more than the declared number of outputs (0)."),
          NULL);
    }
    if (nrhs > 3) {
        mlfError(
          mxCreateString(
            "Run-time Error: File: recarga_2_3/RoffDpth_CreateFcn Line: 60"
            "2 Column: 1 The function \"recarga_2_3/RoffDpth_CreateFcn\" w"
            "as called with more than the declared number of inputs (3)."),
          NULL);
    }
    for (i = 0; i < 3 && i < nrhs; ++i) {
        mprhs[i] = prhs[i];
    }
    for (; i < 3; ++i) {
        mprhs[i] = NULL;
    }
    mlfEnterNewContext(0, 3, mprhs[0], mprhs[1], mprhs[2]);
    Mrecarga_2_3_RoffDpth_CreateFcn(mprhs[0], mprhs[1], mprhs[2]);
    mlfRestorePreviousContext(0, 3, mprhs[0], mprhs[1], mprhs[2]);
}

/*
 * The function "mlfRecarga_2_3_RoffDpth_Callback" contains the normal
 * interface for the "recarga_2_3/RoffDpth_Callback" M-function from file
 * "u:\final_recarga6\recarga\recarga_2_3.m" (lines 617-627). This function
 * processes any input arguments and passes them to the implementation version
 * of the function, appearing above.
 */
static void mlfRecarga_2_3_RoffDpth_Callback(mxArray * hObject,
                                             mxArray * eventdata,
                                             mxArray * handles) {
    mlfEnterNewContext(0, 3, hObject, eventdata, handles);
    Mrecarga_2_3_RoffDpth_Callback(hObject, eventdata, handles);
    mlfRestorePreviousContext(0, 3, hObject, eventdata, handles);
}

/*
 * The function "mlxRecarga_2_3_RoffDpth_Callback" contains the feval interface
 * for the "recarga_2_3/RoffDpth_Callback" M-function from file
 * "u:\final_recarga6\recarga\recarga_2_3.m" (lines 617-627). The feval
 * function calls the implementation version of recarga_2_3/RoffDpth_Callback
 * through this function. This function processes any input arguments and
 * passes them to the implementation version of the function, appearing above.
 */
static void mlxRecarga_2_3_RoffDpth_Callback(int nlhs,
                                             mxArray * plhs[],
                                             int nrhs,
                                             mxArray * prhs[]) {
    mxArray * mprhs[3];
    int i;
    if (nlhs > 0) {
        mlfError(
          mxCreateString(
            "Run-time Error: File: recarga_2_3/RoffDpth_Callback Line: 617"
            " Column: 1 The function \"recarga_2_3/RoffDpth_Callback\" was"
            " called with more than the declared number of outputs (0)."),
          NULL);
    }
    if (nrhs > 3) {
        mlfError(
          mxCreateString(
            "Run-time Error: File: recarga_2_3/RoffDpth_Callback Line: 617"
            " Column: 1 The function \"recarga_2_3/RoffDpth_Callback\" was"
            " called with more than the declared number of inputs (3)."),
          NULL);
    }
    for (i = 0; i < 3 && i < nrhs; ++i) {
        mprhs[i] = prhs[i];
    }
    for (; i < 3; ++i) {
        mprhs[i] = NULL;
    }
    mlfEnterNewContext(0, 3, mprhs[0], mprhs[1], mprhs[2]);
    Mrecarga_2_3_RoffDpth_Callback(mprhs[0], mprhs[1], mprhs[2]);
    mlfRestorePreviousContext(0, 3, mprhs[0], mprhs[1], mprhs[2]);
}

/*
 * The function "mlfRecarga_2_3_RchrgDpth_CreateFcn" contains the normal
 * interface for the "recarga_2_3/RchrgDpth_CreateFcn" M-function from file
 * "u:\final_recarga6\recarga\recarga_2_3.m" (lines 627-642). This function
 * processes any input arguments and passes them to the implementation version
 * of the function, appearing above.
 */
static void mlfRecarga_2_3_RchrgDpth_CreateFcn(mxArray * hObject,
                                               mxArray * eventdata,
                                               mxArray * handles) {
    mlfEnterNewContext(0, 3, hObject, eventdata, handles);
    Mrecarga_2_3_RchrgDpth_CreateFcn(hObject, eventdata, handles);
    mlfRestorePreviousContext(0, 3, hObject, eventdata, handles);
}

/*
 * The function "mlxRecarga_2_3_RchrgDpth_CreateFcn" contains the feval
 * interface for the "recarga_2_3/RchrgDpth_CreateFcn" M-function from file
 * "u:\final_recarga6\recarga\recarga_2_3.m" (lines 627-642). The feval
 * function calls the implementation version of recarga_2_3/RchrgDpth_CreateFcn
 * through this function. This function processes any input arguments and
 * passes them to the implementation version of the function, appearing above.
 */
static void mlxRecarga_2_3_RchrgDpth_CreateFcn(int nlhs,
                                               mxArray * plhs[],
                                               int nrhs,
                                               mxArray * prhs[]) {
    mxArray * mprhs[3];
    int i;
    if (nlhs > 0) {
        mlfError(
          mxCreateString(
            "Run-time Error: File: recarga_2_3/RchrgDpth_CreateFcn Line: 62"
            "7 Column: 1 The function \"recarga_2_3/RchrgDpth_CreateFcn\" w"
            "as called with more than the declared number of outputs (0)."),
          NULL);
    }
    if (nrhs > 3) {
        mlfError(
          mxCreateString(
            "Run-time Error: File: recarga_2_3/RchrgDpth_CreateFcn Line: 62"
            "7 Column: 1 The function \"recarga_2_3/RchrgDpth_CreateFcn\" w"
            "as called with more than the declared number of inputs (3)."),
          NULL);
    }
    for (i = 0; i < 3 && i < nrhs; ++i) {
        mprhs[i] = prhs[i];
    }
    for (; i < 3; ++i) {
        mprhs[i] = NULL;
    }
    mlfEnterNewContext(0, 3, mprhs[0], mprhs[1], mprhs[2]);
    Mrecarga_2_3_RchrgDpth_CreateFcn(mprhs[0], mprhs[1], mprhs[2]);
    mlfRestorePreviousContext(0, 3, mprhs[0], mprhs[1], mprhs[2]);
}

/*
 * The function "mlfRecarga_2_3_RchrgDpth_Callback" contains the normal
 * interface for the "recarga_2_3/RchrgDpth_Callback" M-function from file
 * "u:\final_recarga6\recarga\recarga_2_3.m" (lines 642-652). This function
 * processes any input arguments and passes them to the implementation version
 * of the function, appearing above.
 */
static void mlfRecarga_2_3_RchrgDpth_Callback(mxArray * hObject,
                                              mxArray * eventdata,
                                              mxArray * handles) {
    mlfEnterNewContext(0, 3, hObject, eventdata, handles);
    Mrecarga_2_3_RchrgDpth_Callback(hObject, eventdata, handles);
    mlfRestorePreviousContext(0, 3, hObject, eventdata, handles);
}

/*
 * The function "mlxRecarga_2_3_RchrgDpth_Callback" contains the feval
 * interface for the "recarga_2_3/RchrgDpth_Callback" M-function from file
 * "u:\final_recarga6\recarga\recarga_2_3.m" (lines 642-652). The feval
 * function calls the implementation version of recarga_2_3/RchrgDpth_Callback
 * through this function. This function processes any input arguments and
 * passes them to the implementation version of the function, appearing above.
 */
static void mlxRecarga_2_3_RchrgDpth_Callback(int nlhs,
                                              mxArray * plhs[],
                                              int nrhs,
                                              mxArray * prhs[]) {
    mxArray * mprhs[3];
    int i;
    if (nlhs > 0) {
        mlfError(
          mxCreateString(
            "Run-time Error: File: recarga_2_3/RchrgDpth_Callback Line: 642"
            " Column: 1 The function \"recarga_2_3/RchrgDpth_Callback\" was"
            " called with more than the declared number of outputs (0)."),
          NULL);
    }
    if (nrhs > 3) {
        mlfError(
          mxCreateString(
            "Run-time Error: File: recarga_2_3/RchrgDpth_Callback Line: 64"
            "2 Column: 1 The function \"recarga_2_3/RchrgDpth_Callback\" w"
            "as called with more than the declared number of inputs (3)."),
          NULL);
    }
    for (i = 0; i < 3 && i < nrhs; ++i) {
        mprhs[i] = prhs[i];
    }
    for (; i < 3; ++i) {
        mprhs[i] = NULL;
    }
    mlfEnterNewContext(0, 3, mprhs[0], mprhs[1], mprhs[2]);
    Mrecarga_2_3_RchrgDpth_Callback(mprhs[0], mprhs[1], mprhs[2]);
    mlfRestorePreviousContext(0, 3, mprhs[0], mprhs[1], mprhs[2]);
}

/*
 * The function "mlfRecarga_2_3_EvapDpth_CreateFcn" contains the normal
 * interface for the "recarga_2_3/EvapDpth_CreateFcn" M-function from file
 * "u:\final_recarga6\recarga\recarga_2_3.m" (lines 652-667). This function
 * processes any input arguments and passes them to the implementation version
 * of the function, appearing above.
 */
static void mlfRecarga_2_3_EvapDpth_CreateFcn(mxArray * hObject,
                                              mxArray * eventdata,
                                              mxArray * handles) {
    mlfEnterNewContext(0, 3, hObject, eventdata, handles);
    Mrecarga_2_3_EvapDpth_CreateFcn(hObject, eventdata, handles);
    mlfRestorePreviousContext(0, 3, hObject, eventdata, handles);
}

/*
 * The function "mlxRecarga_2_3_EvapDpth_CreateFcn" contains the feval
 * interface for the "recarga_2_3/EvapDpth_CreateFcn" M-function from file
 * "u:\final_recarga6\recarga\recarga_2_3.m" (lines 652-667). The feval
 * function calls the implementation version of recarga_2_3/EvapDpth_CreateFcn
 * through this function. This function processes any input arguments and
 * passes them to the implementation version of the function, appearing above.
 */
static void mlxRecarga_2_3_EvapDpth_CreateFcn(int nlhs,
                                              mxArray * plhs[],
                                              int nrhs,
                                              mxArray * prhs[]) {
    mxArray * mprhs[3];
    int i;
    if (nlhs > 0) {
        mlfError(
          mxCreateString(
            "Run-time Error: File: recarga_2_3/EvapDpth_CreateFcn Line: 652"
            " Column: 1 The function \"recarga_2_3/EvapDpth_CreateFcn\" was"
            " called with more than the declared number of outputs (0)."),
          NULL);
    }
    if (nrhs > 3) {
        mlfError(
          mxCreateString(
            "Run-time Error: File: recarga_2_3/EvapDpth_CreateFcn Line: 65"
            "2 Column: 1 The function \"recarga_2_3/EvapDpth_CreateFcn\" w"
            "as called with more than the declared number of inputs (3)."),
          NULL);
    }
    for (i = 0; i < 3 && i < nrhs; ++i) {
        mprhs[i] = prhs[i];
    }
    for (; i < 3; ++i) {
        mprhs[i] = NULL;
    }
    mlfEnterNewContext(0, 3, mprhs[0], mprhs[1], mprhs[2]);
    Mrecarga_2_3_EvapDpth_CreateFcn(mprhs[0], mprhs[1], mprhs[2]);
    mlfRestorePreviousContext(0, 3, mprhs[0], mprhs[1], mprhs[2]);
}

/*
 * The function "mlfRecarga_2_3_EvapDpth_Callback" contains the normal
 * interface for the "recarga_2_3/EvapDpth_Callback" M-function from file
 * "u:\final_recarga6\recarga\recarga_2_3.m" (lines 667-677). This function
 * processes any input arguments and passes them to the implementation version
 * of the function, appearing above.
 */
static void mlfRecarga_2_3_EvapDpth_Callback(mxArray * hObject,
                                             mxArray * eventdata,
                                             mxArray * handles) {
    mlfEnterNewContext(0, 3, hObject, eventdata, handles);
    Mrecarga_2_3_EvapDpth_Callback(hObject, eventdata, handles);
    mlfRestorePreviousContext(0, 3, hObject, eventdata, handles);
}

/*
 * The function "mlxRecarga_2_3_EvapDpth_Callback" contains the feval interface
 * for the "recarga_2_3/EvapDpth_Callback" M-function from file
 * "u:\final_recarga6\recarga\recarga_2_3.m" (lines 667-677). The feval
 * function calls the implementation version of recarga_2_3/EvapDpth_Callback
 * through this function. This function processes any input arguments and
 * passes them to the implementation version of the function, appearing above.
 */
static void mlxRecarga_2_3_EvapDpth_Callback(int nlhs,
                                             mxArray * plhs[],
                                             int nrhs,
                                             mxArray * prhs[]) {
    mxArray * mprhs[3];
    int i;
    if (nlhs > 0) {
        mlfError(
          mxCreateString(
            "Run-time Error: File: recarga_2_3/EvapDpth_Callback Line: 667"
            " Column: 1 The function \"recarga_2_3/EvapDpth_Callback\" was"
            " called with more than the declared number of outputs (0)."),
          NULL);
    }
    if (nrhs > 3) {
        mlfError(
          mxCreateString(
            "Run-time Error: File: recarga_2_3/EvapDpth_Callback Line: 667"
            " Column: 1 The function \"recarga_2_3/EvapDpth_Callback\" was"
            " called with more than the declared number of inputs (3)."),
          NULL);
    }
    for (i = 0; i < 3 && i < nrhs; ++i) {
        mprhs[i] = prhs[i];
    }
    for (; i < 3; ++i) {
        mprhs[i] = NULL;
    }
    mlfEnterNewContext(0, 3, mprhs[0], mprhs[1], mprhs[2]);
    Mrecarga_2_3_EvapDpth_Callback(mprhs[0], mprhs[1], mprhs[2]);
    mlfRestorePreviousContext(0, 3, mprhs[0], mprhs[1], mprhs[2]);
}

/*
 * The function "mlfRecarga_2_3_RnOnDpth_CreateFcn" contains the normal
 * interface for the "recarga_2_3/RnOnDpth_CreateFcn" M-function from file
 * "u:\final_recarga6\recarga\recarga_2_3.m" (lines 677-692). This function
 * processes any input arguments and passes them to the implementation version
 * of the function, appearing above.
 */
static void mlfRecarga_2_3_RnOnDpth_CreateFcn(mxArray * hObject,
                                              mxArray * eventdata,
                                              mxArray * handles) {
    mlfEnterNewContext(0, 3, hObject, eventdata, handles);
    Mrecarga_2_3_RnOnDpth_CreateFcn(hObject, eventdata, handles);
    mlfRestorePreviousContext(0, 3, hObject, eventdata, handles);
}

/*
 * The function "mlxRecarga_2_3_RnOnDpth_CreateFcn" contains the feval
 * interface for the "recarga_2_3/RnOnDpth_CreateFcn" M-function from file
 * "u:\final_recarga6\recarga\recarga_2_3.m" (lines 677-692). The feval
 * function calls the implementation version of recarga_2_3/RnOnDpth_CreateFcn
 * through this function. This function processes any input arguments and
 * passes them to the implementation version of the function, appearing above.
 */
static void mlxRecarga_2_3_RnOnDpth_CreateFcn(int nlhs,
                                              mxArray * plhs[],
                                              int nrhs,
                                              mxArray * prhs[]) {
    mxArray * mprhs[3];
    int i;
    if (nlhs > 0) {
        mlfError(
          mxCreateString(
            "Run-time Error: File: recarga_2_3/RnOnDpth_CreateFcn Line: 677"
            " Column: 1 The function \"recarga_2_3/RnOnDpth_CreateFcn\" was"
            " called with more than the declared number of outputs (0)."),
          NULL);
    }
    if (nrhs > 3) {
        mlfError(
          mxCreateString(
            "Run-time Error: File: recarga_2_3/RnOnDpth_CreateFcn Line: 67"
            "7 Column: 1 The function \"recarga_2_3/RnOnDpth_CreateFcn\" w"
            "as called with more than the declared number of inputs (3)."),
          NULL);
    }
    for (i = 0; i < 3 && i < nrhs; ++i) {
        mprhs[i] = prhs[i];
    }
    for (; i < 3; ++i) {
        mprhs[i] = NULL;
    }
    mlfEnterNewContext(0, 3, mprhs[0], mprhs[1], mprhs[2]);
    Mrecarga_2_3_RnOnDpth_CreateFcn(mprhs[0], mprhs[1], mprhs[2]);
    mlfRestorePreviousContext(0, 3, mprhs[0], mprhs[1], mprhs[2]);
}

/*
 * The function "mlfRecarga_2_3_RnOnDpth_Callback" contains the normal
 * interface for the "recarga_2_3/RnOnDpth_Callback" M-function from file
 * "u:\final_recarga6\recarga\recarga_2_3.m" (lines 692-702). This function
 * processes any input arguments and passes them to the implementation version
 * of the function, appearing above.
 */
static void mlfRecarga_2_3_RnOnDpth_Callback(mxArray * hObject,
                                             mxArray * eventdata,
                                             mxArray * handles) {
    mlfEnterNewContext(0, 3, hObject, eventdata, handles);
    Mrecarga_2_3_RnOnDpth_Callback(hObject, eventdata, handles);
    mlfRestorePreviousContext(0, 3, hObject, eventdata, handles);
}

/*
 * The function "mlxRecarga_2_3_RnOnDpth_Callback" contains the feval interface
 * for the "recarga_2_3/RnOnDpth_Callback" M-function from file
 * "u:\final_recarga6\recarga\recarga_2_3.m" (lines 692-702). The feval
 * function calls the implementation version of recarga_2_3/RnOnDpth_Callback
 * through this function. This function processes any input arguments and
 * passes them to the implementation version of the function, appearing above.
 */
static void mlxRecarga_2_3_RnOnDpth_Callback(int nlhs,
                                             mxArray * plhs[],
                                             int nrhs,
                                             mxArray * prhs[]) {
    mxArray * mprhs[3];
    int i;
    if (nlhs > 0) {
        mlfError(
          mxCreateString(
            "Run-time Error: File: recarga_2_3/RnOnDpth_Callback Line: 692"
            " Column: 1 The function \"recarga_2_3/RnOnDpth_Callback\" was"
            " called with more than the declared number of outputs (0)."),
          NULL);
    }
    if (nrhs > 3) {
        mlfError(
          mxCreateString(
            "Run-time Error: File: recarga_2_3/RnOnDpth_Callback Line: 692"
            " Column: 1 The function \"recarga_2_3/RnOnDpth_Callback\" was"
            " called with more than the declared number of inputs (3)."),
          NULL);
    }
    for (i = 0; i < 3 && i < nrhs; ++i) {
        mprhs[i] = prhs[i];
    }
    for (; i < 3; ++i) {
        mprhs[i] = NULL;
    }
    mlfEnterNewContext(0, 3, mprhs[0], mprhs[1], mprhs[2]);
    Mrecarga_2_3_RnOnDpth_Callback(mprhs[0], mprhs[1], mprhs[2]);
    mlfRestorePreviousContext(0, 3, mprhs[0], mprhs[1], mprhs[2]);
}

/*
 * The function "mlfRecarga_2_3_UdVol_CreateFcn" contains the normal interface
 * for the "recarga_2_3/UdVol_CreateFcn" M-function from file
 * "u:\final_recarga6\recarga\recarga_2_3.m" (lines 702-717). This function
 * processes any input arguments and passes them to the implementation version
 * of the function, appearing above.
 */
static void mlfRecarga_2_3_UdVol_CreateFcn(mxArray * hObject,
                                           mxArray * eventdata,
                                           mxArray * handles) {
    mlfEnterNewContext(0, 3, hObject, eventdata, handles);
    Mrecarga_2_3_UdVol_CreateFcn(hObject, eventdata, handles);
    mlfRestorePreviousContext(0, 3, hObject, eventdata, handles);
}

/*
 * The function "mlxRecarga_2_3_UdVol_CreateFcn" contains the feval interface
 * for the "recarga_2_3/UdVol_CreateFcn" M-function from file
 * "u:\final_recarga6\recarga\recarga_2_3.m" (lines 702-717). The feval
 * function calls the implementation version of recarga_2_3/UdVol_CreateFcn
 * through this function. This function processes any input arguments and
 * passes them to the implementation version of the function, appearing above.
 */
static void mlxRecarga_2_3_UdVol_CreateFcn(int nlhs,
                                           mxArray * plhs[],
                                           int nrhs,
                                           mxArray * prhs[]) {
    mxArray * mprhs[3];
    int i;
    if (nlhs > 0) {
        mlfError(
          mxCreateString(
            "Run-time Error: File: recarga_2_3/UdVol_CreateFcn Line: 702 "
            "Column: 1 The function \"recarga_2_3/UdVol_CreateFcn\" was c"
            "alled with more than the declared number of outputs (0)."),
          NULL);
    }
    if (nrhs > 3) {
        mlfError(
          mxCreateString(
            "Run-time Error: File: recarga_2_3/UdVol_CreateFcn Line: 702"
            " Column: 1 The function \"recarga_2_3/UdVol_CreateFcn\" was"
            " called with more than the declared number of inputs (3)."),
          NULL);
    }
    for (i = 0; i < 3 && i < nrhs; ++i) {
        mprhs[i] = prhs[i];
    }
    for (; i < 3; ++i) {
        mprhs[i] = NULL;
    }
    mlfEnterNewContext(0, 3, mprhs[0], mprhs[1], mprhs[2]);
    Mrecarga_2_3_UdVol_CreateFcn(mprhs[0], mprhs[1], mprhs[2]);
    mlfRestorePreviousContext(0, 3, mprhs[0], mprhs[1], mprhs[2]);
}

/*
 * The function "mlfRecarga_2_3_UdVol_Callback" contains the normal interface
 * for the "recarga_2_3/UdVol_Callback" M-function from file
 * "u:\final_recarga6\recarga\recarga_2_3.m" (lines 717-727). This function
 * processes any input arguments and passes them to the implementation version
 * of the function, appearing above.
 */
static void mlfRecarga_2_3_UdVol_Callback(mxArray * hObject,
                                          mxArray * eventdata,
                                          mxArray * handles) {
    mlfEnterNewContext(0, 3, hObject, eventdata, handles);
    Mrecarga_2_3_UdVol_Callback(hObject, eventdata, handles);
    mlfRestorePreviousContext(0, 3, hObject, eventdata, handles);
}

/*
 * The function "mlxRecarga_2_3_UdVol_Callback" contains the feval interface
 * for the "recarga_2_3/UdVol_Callback" M-function from file
 * "u:\final_recarga6\recarga\recarga_2_3.m" (lines 717-727). The feval
 * function calls the implementation version of recarga_2_3/UdVol_Callback
 * through this function. This function processes any input arguments and
 * passes them to the implementation version of the function, appearing above.
 */
static void mlxRecarga_2_3_UdVol_Callback(int nlhs,
                                          mxArray * plhs[],
                                          int nrhs,
                                          mxArray * prhs[]) {
    mxArray * mprhs[3];
    int i;
    if (nlhs > 0) {
        mlfError(
          mxCreateString(
            "Run-time Error: File: recarga_2_3/UdVol_Callback Line: 717 "
            "Column: 1 The function \"recarga_2_3/UdVol_Callback\" was c"
            "alled with more than the declared number of outputs (0)."),
          NULL);
    }
    if (nrhs > 3) {
        mlfError(
          mxCreateString(
            "Run-time Error: File: recarga_2_3/UdVol_Callback Line: 717 "
            "Column: 1 The function \"recarga_2_3/UdVol_Callback\" was c"
            "alled with more than the declared number of inputs (3)."),
          NULL);
    }
    for (i = 0; i < 3 && i < nrhs; ++i) {
        mprhs[i] = prhs[i];
    }
    for (; i < 3; ++i) {
        mprhs[i] = NULL;
    }
    mlfEnterNewContext(0, 3, mprhs[0], mprhs[1], mprhs[2]);
    Mrecarga_2_3_UdVol_Callback(mprhs[0], mprhs[1], mprhs[2]);
    mlfRestorePreviousContext(0, 3, mprhs[0], mprhs[1], mprhs[2]);
}

/*
 * The function "mlfRecarga_2_3_UdFrac_CreateFcn" contains the normal interface
 * for the "recarga_2_3/UdFrac_CreateFcn" M-function from file
 * "u:\final_recarga6\recarga\recarga_2_3.m" (lines 727-742). This function
 * processes any input arguments and passes them to the implementation version
 * of the function, appearing above.
 */
static void mlfRecarga_2_3_UdFrac_CreateFcn(mxArray * hObject,
                                            mxArray * eventdata,
                                            mxArray * handles) {
    mlfEnterNewContext(0, 3, hObject, eventdata, handles);
    Mrecarga_2_3_UdFrac_CreateFcn(hObject, eventdata, handles);
    mlfRestorePreviousContext(0, 3, hObject, eventdata, handles);
}

/*
 * The function "mlxRecarga_2_3_UdFrac_CreateFcn" contains the feval interface
 * for the "recarga_2_3/UdFrac_CreateFcn" M-function from file
 * "u:\final_recarga6\recarga\recarga_2_3.m" (lines 727-742). The feval
 * function calls the implementation version of recarga_2_3/UdFrac_CreateFcn
 * through this function. This function processes any input arguments and
 * passes them to the implementation version of the function, appearing above.
 */
static void mlxRecarga_2_3_UdFrac_CreateFcn(int nlhs,
                                            mxArray * plhs[],
                                            int nrhs,
                                            mxArray * prhs[]) {
    mxArray * mprhs[3];
    int i;
    if (nlhs > 0) {
        mlfError(
          mxCreateString(
            "Run-time Error: File: recarga_2_3/UdFrac_CreateFcn Line: 727"
            " Column: 1 The function \"recarga_2_3/UdFrac_CreateFcn\" was"
            " called with more than the declared number of outputs (0)."),
          NULL);
    }
    if (nrhs > 3) {
        mlfError(
          mxCreateString(
            "Run-time Error: File: recarga_2_3/UdFrac_CreateFcn Line: 727"
            " Column: 1 The function \"recarga_2_3/UdFrac_CreateFcn\" was"
            " called with more than the declared number of inputs (3)."),
          NULL);
    }
    for (i = 0; i < 3 && i < nrhs; ++i) {
        mprhs[i] = prhs[i];
    }
    for (; i < 3; ++i) {
        mprhs[i] = NULL;
    }
    mlfEnterNewContext(0, 3, mprhs[0], mprhs[1], mprhs[2]);
    Mrecarga_2_3_UdFrac_CreateFcn(mprhs[0], mprhs[1], mprhs[2]);
    mlfRestorePreviousContext(0, 3, mprhs[0], mprhs[1], mprhs[2]);
}

/*
 * The function "mlfRecarga_2_3_UdFrac_Callback" contains the normal interface
 * for the "recarga_2_3/UdFrac_Callback" M-function from file
 * "u:\final_recarga6\recarga\recarga_2_3.m" (lines 742-752). This function
 * processes any input arguments and passes them to the implementation version
 * of the function, appearing above.
 */
static void mlfRecarga_2_3_UdFrac_Callback(mxArray * hObject,
                                           mxArray * eventdata,
                                           mxArray * handles) {
    mlfEnterNewContext(0, 3, hObject, eventdata, handles);
    Mrecarga_2_3_UdFrac_Callback(hObject, eventdata, handles);
    mlfRestorePreviousContext(0, 3, hObject, eventdata, handles);
}

/*
 * The function "mlxRecarga_2_3_UdFrac_Callback" contains the feval interface
 * for the "recarga_2_3/UdFrac_Callback" M-function from file
 * "u:\final_recarga6\recarga\recarga_2_3.m" (lines 742-752). The feval
 * function calls the implementation version of recarga_2_3/UdFrac_Callback
 * through this function. This function processes any input arguments and
 * passes them to the implementation version of the function, appearing above.
 */
static void mlxRecarga_2_3_UdFrac_Callback(int nlhs,
                                           mxArray * plhs[],
                                           int nrhs,
                                           mxArray * prhs[]) {
    mxArray * mprhs[3];
    int i;
    if (nlhs > 0) {
        mlfError(
          mxCreateString(
            "Run-time Error: File: recarga_2_3/UdFrac_Callback Line: 742 "
            "Column: 1 The function \"recarga_2_3/UdFrac_Callback\" was c"
            "alled with more than the declared number of outputs (0)."),
          NULL);
    }
    if (nrhs > 3) {
        mlfError(
          mxCreateString(
            "Run-time Error: File: recarga_2_3/UdFrac_Callback Line: 742"
            " Column: 1 The function \"recarga_2_3/UdFrac_Callback\" was"
            " called with more than the declared number of inputs (3)."),
          NULL);
    }
    for (i = 0; i < 3 && i < nrhs; ++i) {
        mprhs[i] = prhs[i];
    }
    for (; i < 3; ++i) {
        mprhs[i] = NULL;
    }
    mlfEnterNewContext(0, 3, mprhs[0], mprhs[1], mprhs[2]);
    Mrecarga_2_3_UdFrac_Callback(mprhs[0], mprhs[1], mprhs[2]);
    mlfRestorePreviousContext(0, 3, mprhs[0], mprhs[1], mprhs[2]);
}

/*
 * The function "mlfRecarga_2_3_UdDpth_CreateFcn" contains the normal interface
 * for the "recarga_2_3/UdDpth_CreateFcn" M-function from file
 * "u:\final_recarga6\recarga\recarga_2_3.m" (lines 752-767). This function
 * processes any input arguments and passes them to the implementation version
 * of the function, appearing above.
 */
static void mlfRecarga_2_3_UdDpth_CreateFcn(mxArray * hObject,
                                            mxArray * eventdata,
                                            mxArray * handles) {
    mlfEnterNewContext(0, 3, hObject, eventdata, handles);
    Mrecarga_2_3_UdDpth_CreateFcn(hObject, eventdata, handles);
    mlfRestorePreviousContext(0, 3, hObject, eventdata, handles);
}

/*
 * The function "mlxRecarga_2_3_UdDpth_CreateFcn" contains the feval interface
 * for the "recarga_2_3/UdDpth_CreateFcn" M-function from file
 * "u:\final_recarga6\recarga\recarga_2_3.m" (lines 752-767). The feval
 * function calls the implementation version of recarga_2_3/UdDpth_CreateFcn
 * through this function. This function processes any input arguments and
 * passes them to the implementation version of the function, appearing above.
 */
static void mlxRecarga_2_3_UdDpth_CreateFcn(int nlhs,
                                            mxArray * plhs[],
                                            int nrhs,
                                            mxArray * prhs[]) {
    mxArray * mprhs[3];
    int i;
    if (nlhs > 0) {
        mlfError(
          mxCreateString(
            "Run-time Error: File: recarga_2_3/UdDpth_CreateFcn Line: 752"
            " Column: 1 The function \"recarga_2_3/UdDpth_CreateFcn\" was"
            " called with more than the declared number of outputs (0)."),
          NULL);
    }
    if (nrhs > 3) {
        mlfError(
          mxCreateString(
            "Run-time Error: File: recarga_2_3/UdDpth_CreateFcn Line: 752"
            " Column: 1 The function \"recarga_2_3/UdDpth_CreateFcn\" was"
            " called with more than the declared number of inputs (3)."),
          NULL);
    }
    for (i = 0; i < 3 && i < nrhs; ++i) {
        mprhs[i] = prhs[i];
    }
    for (; i < 3; ++i) {
        mprhs[i] = NULL;
    }
    mlfEnterNewContext(0, 3, mprhs[0], mprhs[1], mprhs[2]);
    Mrecarga_2_3_UdDpth_CreateFcn(mprhs[0], mprhs[1], mprhs[2]);
    mlfRestorePreviousContext(0, 3, mprhs[0], mprhs[1], mprhs[2]);
}

/*
 * The function "mlfRecarga_2_3_UdDpth_Callback" contains the normal interface
 * for the "recarga_2_3/UdDpth_Callback" M-function from file
 * "u:\final_recarga6\recarga\recarga_2_3.m" (lines 767-777). This function
 * processes any input arguments and passes them to the implementation version
 * of the function, appearing above.
 */
static void mlfRecarga_2_3_UdDpth_Callback(mxArray * hObject,
                                           mxArray * eventdata,
                                           mxArray * handles) {
    mlfEnterNewContext(0, 3, hObject, eventdata, handles);
    Mrecarga_2_3_UdDpth_Callback(hObject, eventdata, handles);
    mlfRestorePreviousContext(0, 3, hObject, eventdata, handles);
}

/*
 * The function "mlxRecarga_2_3_UdDpth_Callback" contains the feval interface
 * for the "recarga_2_3/UdDpth_Callback" M-function from file
 * "u:\final_recarga6\recarga\recarga_2_3.m" (lines 767-777). The feval
 * function calls the implementation version of recarga_2_3/UdDpth_Callback
 * through this function. This function processes any input arguments and
 * passes them to the implementation version of the function, appearing above.
 */
static void mlxRecarga_2_3_UdDpth_Callback(int nlhs,
                                           mxArray * plhs[],
                                           int nrhs,
                                           mxArray * prhs[]) {
    mxArray * mprhs[3];
    int i;
    if (nlhs > 0) {
        mlfError(
          mxCreateString(
            "Run-time Error: File: recarga_2_3/UdDpth_Callback Line: 767 "
            "Column: 1 The function \"recarga_2_3/UdDpth_Callback\" was c"
            "alled with more than the declared number of outputs (0)."),
          NULL);
    }
    if (nrhs > 3) {
        mlfError(
          mxCreateString(
            "Run-time Error: File: recarga_2_3/UdDpth_Callback Line: 767"
            " Column: 1 The function \"recarga_2_3/UdDpth_Callback\" was"
            " called with more than the declared number of inputs (3)."),
          NULL);
    }
    for (i = 0; i < 3 && i < nrhs; ++i) {
        mprhs[i] = prhs[i];
    }
    for (; i < 3; ++i) {
        mprhs[i] = NULL;
    }
    mlfEnterNewContext(0, 3, mprhs[0], mprhs[1], mprhs[2]);
    Mrecarga_2_3_UdDpth_Callback(mprhs[0], mprhs[1], mprhs[2]);
    mlfRestorePreviousContext(0, 3, mprhs[0], mprhs[1], mprhs[2]);
}

/*
 * The function "mlfRecarga_2_3_UFlow_CreateFcn" contains the normal interface
 * for the "recarga_2_3/UFlow_CreateFcn" M-function from file
 * "u:\final_recarga6\recarga\recarga_2_3.m" (lines 777-792). This function
 * processes any input arguments and passes them to the implementation version
 * of the function, appearing above.
 */
static void mlfRecarga_2_3_UFlow_CreateFcn(mxArray * hObject,
                                           mxArray * eventdata,
                                           mxArray * handles) {
    mlfEnterNewContext(0, 3, hObject, eventdata, handles);
    Mrecarga_2_3_UFlow_CreateFcn(hObject, eventdata, handles);
    mlfRestorePreviousContext(0, 3, hObject, eventdata, handles);
}

/*
 * The function "mlxRecarga_2_3_UFlow_CreateFcn" contains the feval interface
 * for the "recarga_2_3/UFlow_CreateFcn" M-function from file
 * "u:\final_recarga6\recarga\recarga_2_3.m" (lines 777-792). The feval
 * function calls the implementation version of recarga_2_3/UFlow_CreateFcn
 * through this function. This function processes any input arguments and
 * passes them to the implementation version of the function, appearing above.
 */
static void mlxRecarga_2_3_UFlow_CreateFcn(int nlhs,
                                           mxArray * plhs[],
                                           int nrhs,
                                           mxArray * prhs[]) {
    mxArray * mprhs[3];
    int i;
    if (nlhs > 0) {
        mlfError(
          mxCreateString(
            "Run-time Error: File: recarga_2_3/UFlow_CreateFcn Line: 777 "
            "Column: 1 The function \"recarga_2_3/UFlow_CreateFcn\" was c"
            "alled with more than the declared number of outputs (0)."),
          NULL);
    }
    if (nrhs > 3) {
        mlfError(
          mxCreateString(
            "Run-time Error: File: recarga_2_3/UFlow_CreateFcn Line: 777"
            " Column: 1 The function \"recarga_2_3/UFlow_CreateFcn\" was"
            " called with more than the declared number of inputs (3)."),
          NULL);
    }
    for (i = 0; i < 3 && i < nrhs; ++i) {
        mprhs[i] = prhs[i];
    }
    for (; i < 3; ++i) {
        mprhs[i] = NULL;
    }
    mlfEnterNewContext(0, 3, mprhs[0], mprhs[1], mprhs[2]);
    Mrecarga_2_3_UFlow_CreateFcn(mprhs[0], mprhs[1], mprhs[2]);
    mlfRestorePreviousContext(0, 3, mprhs[0], mprhs[1], mprhs[2]);
}

/*
 * The function "mlfRecarga_2_3_UFlow_Callback" contains the normal interface
 * for the "recarga_2_3/UFlow_Callback" M-function from file
 * "u:\final_recarga6\recarga\recarga_2_3.m" (lines 792-823). This function
 * processes any input arguments and passes them to the implementation version
 * of the function, appearing above.
 */
static void mlfRecarga_2_3_UFlow_Callback(mxArray * hObject,
                                          mxArray * eventdata,
                                          mxArray * handles) {
    mlfEnterNewContext(0, 3, hObject, eventdata, handles);
    Mrecarga_2_3_UFlow_Callback(hObject, eventdata, handles);
    mlfRestorePreviousContext(0, 3, hObject, eventdata, handles);
}

/*
 * The function "mlxRecarga_2_3_UFlow_Callback" contains the feval interface
 * for the "recarga_2_3/UFlow_Callback" M-function from file
 * "u:\final_recarga6\recarga\recarga_2_3.m" (lines 792-823). The feval
 * function calls the implementation version of recarga_2_3/UFlow_Callback
 * through this function. This function processes any input arguments and
 * passes them to the implementation version of the function, appearing above.
 */
static void mlxRecarga_2_3_UFlow_Callback(int nlhs,
                                          mxArray * plhs[],
                                          int nrhs,
                                          mxArray * prhs[]) {
    mxArray * mprhs[3];
    int i;
    if (nlhs > 0) {
        mlfError(
          mxCreateString(
            "Run-time Error: File: recarga_2_3/UFlow_Callback Line: 792 "
            "Column: 1 The function \"recarga_2_3/UFlow_Callback\" was c"
            "alled with more than the declared number of outputs (0)."),
          NULL);
    }
    if (nrhs > 3) {
        mlfError(
          mxCreateString(
            "Run-time Error: File: recarga_2_3/UFlow_Callback Line: 792 "
            "Column: 1 The function \"recarga_2_3/UFlow_Callback\" was c"
            "alled with more than the declared number of inputs (3)."),
          NULL);
    }
    for (i = 0; i < 3 && i < nrhs; ++i) {
        mprhs[i] = prhs[i];
    }
    for (; i < 3; ++i) {
        mprhs[i] = NULL;
    }
    mlfEnterNewContext(0, 3, mprhs[0], mprhs[1], mprhs[2]);
    Mrecarga_2_3_UFlow_Callback(mprhs[0], mprhs[1], mprhs[2]);
    mlfRestorePreviousContext(0, 3, mprhs[0], mprhs[1], mprhs[2]);
}

/*
 * The function "mlfRecarga_2_3_BasinArea_CreateFcn" contains the normal
 * interface for the "recarga_2_3/BasinArea_CreateFcn" M-function from file
 * "u:\final_recarga6\recarga\recarga_2_3.m" (lines 823-838). This function
 * processes any input arguments and passes them to the implementation version
 * of the function, appearing above.
 */
static void mlfRecarga_2_3_BasinArea_CreateFcn(mxArray * hObject,
                                               mxArray * eventdata,
                                               mxArray * handles) {
    mlfEnterNewContext(0, 3, hObject, eventdata, handles);
    Mrecarga_2_3_BasinArea_CreateFcn(hObject, eventdata, handles);
    mlfRestorePreviousContext(0, 3, hObject, eventdata, handles);
}

/*
 * The function "mlxRecarga_2_3_BasinArea_CreateFcn" contains the feval
 * interface for the "recarga_2_3/BasinArea_CreateFcn" M-function from file
 * "u:\final_recarga6\recarga\recarga_2_3.m" (lines 823-838). The feval
 * function calls the implementation version of recarga_2_3/BasinArea_CreateFcn
 * through this function. This function processes any input arguments and
 * passes them to the implementation version of the function, appearing above.
 */
static void mlxRecarga_2_3_BasinArea_CreateFcn(int nlhs,
                                               mxArray * plhs[],
                                               int nrhs,
                                               mxArray * prhs[]) {
    mxArray * mprhs[3];
    int i;
    if (nlhs > 0) {
        mlfError(
          mxCreateString(
            "Run-time Error: File: recarga_2_3/BasinArea_CreateFcn Line: 82"
            "3 Column: 1 The function \"recarga_2_3/BasinArea_CreateFcn\" w"
            "as called with more than the declared number of outputs (0)."),
          NULL);
    }
    if (nrhs > 3) {
        mlfError(
          mxCreateString(
            "Run-time Error: File: recarga_2_3/BasinArea_CreateFcn Line: 82"
            "3 Column: 1 The function \"recarga_2_3/BasinArea_CreateFcn\" w"
            "as called with more than the declared number of inputs (3)."),
          NULL);
    }
    for (i = 0; i < 3 && i < nrhs; ++i) {
        mprhs[i] = prhs[i];
    }
    for (; i < 3; ++i) {
        mprhs[i] = NULL;
    }
    mlfEnterNewContext(0, 3, mprhs[0], mprhs[1], mprhs[2]);
    Mrecarga_2_3_BasinArea_CreateFcn(mprhs[0], mprhs[1], mprhs[2]);
    mlfRestorePreviousContext(0, 3, mprhs[0], mprhs[1], mprhs[2]);
}

/*
 * The function "mlfRecarga_2_3_BasinArea_Callback" contains the normal
 * interface for the "recarga_2_3/BasinArea_Callback" M-function from file
 * "u:\final_recarga6\recarga\recarga_2_3.m" (lines 838-848). This function
 * processes any input arguments and passes them to the implementation version
 * of the function, appearing above.
 */
static void mlfRecarga_2_3_BasinArea_Callback(mxArray * hObject,
                                              mxArray * eventdata,
                                              mxArray * handles) {
    mlfEnterNewContext(0, 3, hObject, eventdata, handles);
    Mrecarga_2_3_BasinArea_Callback(hObject, eventdata, handles);
    mlfRestorePreviousContext(0, 3, hObject, eventdata, handles);
}

/*
 * The function "mlxRecarga_2_3_BasinArea_Callback" contains the feval
 * interface for the "recarga_2_3/BasinArea_Callback" M-function from file
 * "u:\final_recarga6\recarga\recarga_2_3.m" (lines 838-848). The feval
 * function calls the implementation version of recarga_2_3/BasinArea_Callback
 * through this function. This function processes any input arguments and
 * passes them to the implementation version of the function, appearing above.
 */
static void mlxRecarga_2_3_BasinArea_Callback(int nlhs,
                                              mxArray * plhs[],
                                              int nrhs,
                                              mxArray * prhs[]) {
    mxArray * mprhs[3];
    int i;
    if (nlhs > 0) {
        mlfError(
          mxCreateString(
            "Run-time Error: File: recarga_2_3/BasinArea_Callback Line: 838"
            " Column: 1 The function \"recarga_2_3/BasinArea_Callback\" was"
            " called with more than the declared number of outputs (0)."),
          NULL);
    }
    if (nrhs > 3) {
        mlfError(
          mxCreateString(
            "Run-time Error: File: recarga_2_3/BasinArea_Callback Line: 83"
            "8 Column: 1 The function \"recarga_2_3/BasinArea_Callback\" w"
            "as called with more than the declared number of inputs (3)."),
          NULL);
    }
    for (i = 0; i < 3 && i < nrhs; ++i) {
        mprhs[i] = prhs[i];
    }
    for (; i < 3; ++i) {
        mprhs[i] = NULL;
    }
    mlfEnterNewContext(0, 3, mprhs[0], mprhs[1], mprhs[2]);
    Mrecarga_2_3_BasinArea_Callback(mprhs[0], mprhs[1], mprhs[2]);
    mlfRestorePreviousContext(0, 3, mprhs[0], mprhs[1], mprhs[2]);
}

/*
 * The function "mlfRecarga_2_3_Udiam_CreateFcn" contains the normal interface
 * for the "recarga_2_3/Udiam_CreateFcn" M-function from file
 * "u:\final_recarga6\recarga\recarga_2_3.m" (lines 848-863). This function
 * processes any input arguments and passes them to the implementation version
 * of the function, appearing above.
 */
static void mlfRecarga_2_3_Udiam_CreateFcn(mxArray * hObject,
                                           mxArray * eventdata,
                                           mxArray * handles) {
    mlfEnterNewContext(0, 3, hObject, eventdata, handles);
    Mrecarga_2_3_Udiam_CreateFcn(hObject, eventdata, handles);
    mlfRestorePreviousContext(0, 3, hObject, eventdata, handles);
}

/*
 * The function "mlxRecarga_2_3_Udiam_CreateFcn" contains the feval interface
 * for the "recarga_2_3/Udiam_CreateFcn" M-function from file
 * "u:\final_recarga6\recarga\recarga_2_3.m" (lines 848-863). The feval
 * function calls the implementation version of recarga_2_3/Udiam_CreateFcn
 * through this function. This function processes any input arguments and
 * passes them to the implementation version of the function, appearing above.
 */
static void mlxRecarga_2_3_Udiam_CreateFcn(int nlhs,
                                           mxArray * plhs[],
                                           int nrhs,
                                           mxArray * prhs[]) {
    mxArray * mprhs[3];
    int i;
    if (nlhs > 0) {
        mlfError(
          mxCreateString(
            "Run-time Error: File: recarga_2_3/Udiam_CreateFcn Line: 848 "
            "Column: 1 The function \"recarga_2_3/Udiam_CreateFcn\" was c"
            "alled with more than the declared number of outputs (0)."),
          NULL);
    }
    if (nrhs > 3) {
        mlfError(
          mxCreateString(
            "Run-time Error: File: recarga_2_3/Udiam_CreateFcn Line: 848"
            " Column: 1 The function \"recarga_2_3/Udiam_CreateFcn\" was"
            " called with more than the declared number of inputs (3)."),
          NULL);
    }
    for (i = 0; i < 3 && i < nrhs; ++i) {
        mprhs[i] = prhs[i];
    }
    for (; i < 3; ++i) {
        mprhs[i] = NULL;
    }
    mlfEnterNewContext(0, 3, mprhs[0], mprhs[1], mprhs[2]);
    Mrecarga_2_3_Udiam_CreateFcn(mprhs[0], mprhs[1], mprhs[2]);
    mlfRestorePreviousContext(0, 3, mprhs[0], mprhs[1], mprhs[2]);
}

/*
 * The function "mlfRecarga_2_3_Udiam_Callback" contains the normal interface
 * for the "recarga_2_3/Udiam_Callback" M-function from file
 * "u:\final_recarga6\recarga\recarga_2_3.m" (lines 863-894). This function
 * processes any input arguments and passes them to the implementation version
 * of the function, appearing above.
 */
static void mlfRecarga_2_3_Udiam_Callback(mxArray * hObject,
                                          mxArray * eventdata,
                                          mxArray * handles) {
    mlfEnterNewContext(0, 3, hObject, eventdata, handles);
    Mrecarga_2_3_Udiam_Callback(hObject, eventdata, handles);
    mlfRestorePreviousContext(0, 3, hObject, eventdata, handles);
}

/*
 * The function "mlxRecarga_2_3_Udiam_Callback" contains the feval interface
 * for the "recarga_2_3/Udiam_Callback" M-function from file
 * "u:\final_recarga6\recarga\recarga_2_3.m" (lines 863-894). The feval
 * function calls the implementation version of recarga_2_3/Udiam_Callback
 * through this function. This function processes any input arguments and
 * passes them to the implementation version of the function, appearing above.
 */
static void mlxRecarga_2_3_Udiam_Callback(int nlhs,
                                          mxArray * plhs[],
                                          int nrhs,
                                          mxArray * prhs[]) {
    mxArray * mprhs[3];
    int i;
    if (nlhs > 0) {
        mlfError(
          mxCreateString(
            "Run-time Error: File: recarga_2_3/Udiam_Callback Line: 863 "
            "Column: 1 The function \"recarga_2_3/Udiam_Callback\" was c"
            "alled with more than the declared number of outputs (0)."),
          NULL);
    }
    if (nrhs > 3) {
        mlfError(
          mxCreateString(
            "Run-time Error: File: recarga_2_3/Udiam_Callback Line: 863 "
            "Column: 1 The function \"recarga_2_3/Udiam_Callback\" was c"
            "alled with more than the declared number of inputs (3)."),
          NULL);
    }
    for (i = 0; i < 3 && i < nrhs; ++i) {
        mprhs[i] = prhs[i];
    }
    for (; i < 3; ++i) {
        mprhs[i] = NULL;
    }
    mlfEnterNewContext(0, 3, mprhs[0], mprhs[1], mprhs[2]);
    Mrecarga_2_3_Udiam_Callback(mprhs[0], mprhs[1], mprhs[2]);
    mlfRestorePreviousContext(0, 3, mprhs[0], mprhs[1], mprhs[2]);
}

/*
 * The function "mlfRecarga_2_3_AveET_CreateFcn" contains the normal interface
 * for the "recarga_2_3/AveET_CreateFcn" M-function from file
 * "u:\final_recarga6\recarga\recarga_2_3.m" (lines 894-909). This function
 * processes any input arguments and passes them to the implementation version
 * of the function, appearing above.
 */
static void mlfRecarga_2_3_AveET_CreateFcn(mxArray * hObject,
                                           mxArray * eventdata,
                                           mxArray * handles) {
    mlfEnterNewContext(0, 3, hObject, eventdata, handles);
    Mrecarga_2_3_AveET_CreateFcn(hObject, eventdata, handles);
    mlfRestorePreviousContext(0, 3, hObject, eventdata, handles);
}

/*
 * The function "mlxRecarga_2_3_AveET_CreateFcn" contains the feval interface
 * for the "recarga_2_3/AveET_CreateFcn" M-function from file
 * "u:\final_recarga6\recarga\recarga_2_3.m" (lines 894-909). The feval
 * function calls the implementation version of recarga_2_3/AveET_CreateFcn
 * through this function. This function processes any input arguments and
 * passes them to the implementation version of the function, appearing above.
 */
static void mlxRecarga_2_3_AveET_CreateFcn(int nlhs,
                                           mxArray * plhs[],
                                           int nrhs,
                                           mxArray * prhs[]) {
    mxArray * mprhs[3];
    int i;
    if (nlhs > 0) {
        mlfError(
          mxCreateString(
            "Run-time Error: File: recarga_2_3/AveET_CreateFcn Line: 894 "
            "Column: 1 The function \"recarga_2_3/AveET_CreateFcn\" was c"
            "alled with more than the declared number of outputs (0)."),
          NULL);
    }
    if (nrhs > 3) {
        mlfError(
          mxCreateString(
            "Run-time Error: File: recarga_2_3/AveET_CreateFcn Line: 894"
            " Column: 1 The function \"recarga_2_3/AveET_CreateFcn\" was"
            " called with more than the declared number of inputs (3)."),
          NULL);
    }
    for (i = 0; i < 3 && i < nrhs; ++i) {
        mprhs[i] = prhs[i];
    }
    for (; i < 3; ++i) {
        mprhs[i] = NULL;
    }
    mlfEnterNewContext(0, 3, mprhs[0], mprhs[1], mprhs[2]);
    Mrecarga_2_3_AveET_CreateFcn(mprhs[0], mprhs[1], mprhs[2]);
    mlfRestorePreviousContext(0, 3, mprhs[0], mprhs[1], mprhs[2]);
}

/*
 * The function "mlfRecarga_2_3_AveET_Callback" contains the normal interface
 * for the "recarga_2_3/AveET_Callback" M-function from file
 * "u:\final_recarga6\recarga\recarga_2_3.m" (lines 909-922). This function
 * processes any input arguments and passes them to the implementation version
 * of the function, appearing above.
 */
static void mlfRecarga_2_3_AveET_Callback(mxArray * hObject,
                                          mxArray * eventdata,
                                          mxArray * handles) {
    mlfEnterNewContext(0, 3, hObject, eventdata, handles);
    Mrecarga_2_3_AveET_Callback(hObject, eventdata, handles);
    mlfRestorePreviousContext(0, 3, hObject, eventdata, handles);
}

/*
 * The function "mlxRecarga_2_3_AveET_Callback" contains the feval interface
 * for the "recarga_2_3/AveET_Callback" M-function from file
 * "u:\final_recarga6\recarga\recarga_2_3.m" (lines 909-922). The feval
 * function calls the implementation version of recarga_2_3/AveET_Callback
 * through this function. This function processes any input arguments and
 * passes them to the implementation version of the function, appearing above.
 */
static void mlxRecarga_2_3_AveET_Callback(int nlhs,
                                          mxArray * plhs[],
                                          int nrhs,
                                          mxArray * prhs[]) {
    mxArray * mprhs[3];
    int i;
    if (nlhs > 0) {
        mlfError(
          mxCreateString(
            "Run-time Error: File: recarga_2_3/AveET_Callback Line: 909 "
            "Column: 1 The function \"recarga_2_3/AveET_Callback\" was c"
            "alled with more than the declared number of outputs (0)."),
          NULL);
    }
    if (nrhs > 3) {
        mlfError(
          mxCreateString(
            "Run-time Error: File: recarga_2_3/AveET_Callback Line: 909 "
            "Column: 1 The function \"recarga_2_3/AveET_Callback\" was c"
            "alled with more than the declared number of inputs (3)."),
          NULL);
    }
    for (i = 0; i < 3 && i < nrhs; ++i) {
        mprhs[i] = prhs[i];
    }
    for (; i < 3; ++i) {
        mprhs[i] = NULL;
    }
    mlfEnterNewContext(0, 3, mprhs[0], mprhs[1], mprhs[2]);
    Mrecarga_2_3_AveET_Callback(mprhs[0], mprhs[1], mprhs[2]);
    mlfRestorePreviousContext(0, 3, mprhs[0], mprhs[1], mprhs[2]);
}

/*
 * The function "mlfRecarga_2_3_Sd_CreateFcn" contains the normal interface for
 * the "recarga_2_3/Sd_CreateFcn" M-function from file
 * "u:\final_recarga6\recarga\recarga_2_3.m" (lines 922-937). This function
 * processes any input arguments and passes them to the implementation version
 * of the function, appearing above.
 */
static void mlfRecarga_2_3_Sd_CreateFcn(mxArray * hObject,
                                        mxArray * eventdata,
                                        mxArray * handles) {
    mlfEnterNewContext(0, 3, hObject, eventdata, handles);
    Mrecarga_2_3_Sd_CreateFcn(hObject, eventdata, handles);
    mlfRestorePreviousContext(0, 3, hObject, eventdata, handles);
}

/*
 * The function "mlxRecarga_2_3_Sd_CreateFcn" contains the feval interface for
 * the "recarga_2_3/Sd_CreateFcn" M-function from file
 * "u:\final_recarga6\recarga\recarga_2_3.m" (lines 922-937). The feval
 * function calls the implementation version of recarga_2_3/Sd_CreateFcn
 * through this function. This function processes any input arguments and
 * passes them to the implementation version of the function, appearing above.
 */
static void mlxRecarga_2_3_Sd_CreateFcn(int nlhs,
                                        mxArray * plhs[],
                                        int nrhs,
                                        mxArray * prhs[]) {
    mxArray * mprhs[3];
    int i;
    if (nlhs > 0) {
        mlfError(
          mxCreateString(
            "Run-time Error: File: recarga_2_3/Sd_CreateFcn Line: 922 C"
            "olumn: 1 The function \"recarga_2_3/Sd_CreateFcn\" was cal"
            "led with more than the declared number of outputs (0)."),
          NULL);
    }
    if (nrhs > 3) {
        mlfError(
          mxCreateString(
            "Run-time Error: File: recarga_2_3/Sd_CreateFcn Line: 922 "
            "Column: 1 The function \"recarga_2_3/Sd_CreateFcn\" was c"
            "alled with more than the declared number of inputs (3)."),
          NULL);
    }
    for (i = 0; i < 3 && i < nrhs; ++i) {
        mprhs[i] = prhs[i];
    }
    for (; i < 3; ++i) {
        mprhs[i] = NULL;
    }
    mlfEnterNewContext(0, 3, mprhs[0], mprhs[1], mprhs[2]);
    Mrecarga_2_3_Sd_CreateFcn(mprhs[0], mprhs[1], mprhs[2]);
    mlfRestorePreviousContext(0, 3, mprhs[0], mprhs[1], mprhs[2]);
}

/*
 * The function "mlfRecarga_2_3_Sd_Callback" contains the normal interface for
 * the "recarga_2_3/Sd_Callback" M-function from file
 * "u:\final_recarga6\recarga\recarga_2_3.m" (lines 937-947). This function
 * processes any input arguments and passes them to the implementation version
 * of the function, appearing above.
 */
static void mlfRecarga_2_3_Sd_Callback(mxArray * hObject,
                                       mxArray * eventdata,
                                       mxArray * handles) {
    mlfEnterNewContext(0, 3, hObject, eventdata, handles);
    Mrecarga_2_3_Sd_Callback(hObject, eventdata, handles);
    mlfRestorePreviousContext(0, 3, hObject, eventdata, handles);
}

/*
 * The function "mlxRecarga_2_3_Sd_Callback" contains the feval interface for
 * the "recarga_2_3/Sd_Callback" M-function from file
 * "u:\final_recarga6\recarga\recarga_2_3.m" (lines 937-947). The feval
 * function calls the implementation version of recarga_2_3/Sd_Callback through
 * this function. This function processes any input arguments and passes them
 * to the implementation version of the function, appearing above.
 */
static void mlxRecarga_2_3_Sd_Callback(int nlhs,
                                       mxArray * plhs[],
                                       int nrhs,
                                       mxArray * prhs[]) {
    mxArray * mprhs[3];
    int i;
    if (nlhs > 0) {
        mlfError(
          mxCreateString(
            "Run-time Error: File: recarga_2_3/Sd_Callback Line: 937 C"
            "olumn: 1 The function \"recarga_2_3/Sd_Callback\" was cal"
            "led with more than the declared number of outputs (0)."),
          NULL);
    }
    if (nrhs > 3) {
        mlfError(
          mxCreateString(
            "Run-time Error: File: recarga_2_3/Sd_Callback Line: 937 C"
            "olumn: 1 The function \"recarga_2_3/Sd_Callback\" was cal"
            "led with more than the declared number of inputs (3)."),
          NULL);
    }
    for (i = 0; i < 3 && i < nrhs; ++i) {
        mprhs[i] = prhs[i];
    }
    for (; i < 3; ++i) {
        mprhs[i] = NULL;
    }
    mlfEnterNewContext(0, 3, mprhs[0], mprhs[1], mprhs[2]);
    Mrecarga_2_3_Sd_Callback(mprhs[0], mprhs[1], mprhs[2]);
    mlfRestorePreviousContext(0, 3, mprhs[0], mprhs[1], mprhs[2]);
}

/*
 * The function "mlfRecarga_2_3_Srz_CreateFcn" contains the normal interface
 * for the "recarga_2_3/Srz_CreateFcn" M-function from file
 * "u:\final_recarga6\recarga\recarga_2_3.m" (lines 947-962). This function
 * processes any input arguments and passes them to the implementation version
 * of the function, appearing above.
 */
static void mlfRecarga_2_3_Srz_CreateFcn(mxArray * hObject,
                                         mxArray * eventdata,
                                         mxArray * handles) {
    mlfEnterNewContext(0, 3, hObject, eventdata, handles);
    Mrecarga_2_3_Srz_CreateFcn(hObject, eventdata, handles);
    mlfRestorePreviousContext(0, 3, hObject, eventdata, handles);
}

/*
 * The function "mlxRecarga_2_3_Srz_CreateFcn" contains the feval interface for
 * the "recarga_2_3/Srz_CreateFcn" M-function from file
 * "u:\final_recarga6\recarga\recarga_2_3.m" (lines 947-962). The feval
 * function calls the implementation version of recarga_2_3/Srz_CreateFcn
 * through this function. This function processes any input arguments and
 * passes them to the implementation version of the function, appearing above.
 */
static void mlxRecarga_2_3_Srz_CreateFcn(int nlhs,
                                         mxArray * plhs[],
                                         int nrhs,
                                         mxArray * prhs[]) {
    mxArray * mprhs[3];
    int i;
    if (nlhs > 0) {
        mlfError(
          mxCreateString(
            "Run-time Error: File: recarga_2_3/Srz_CreateFcn Line: 947 "
            "Column: 1 The function \"recarga_2_3/Srz_CreateFcn\" was c"
            "alled with more than the declared number of outputs (0)."),
          NULL);
    }
    if (nrhs > 3) {
        mlfError(
          mxCreateString(
            "Run-time Error: File: recarga_2_3/Srz_CreateFcn Line: 947 "
            "Column: 1 The function \"recarga_2_3/Srz_CreateFcn\" was c"
            "alled with more than the declared number of inputs (3)."),
          NULL);
    }
    for (i = 0; i < 3 && i < nrhs; ++i) {
        mprhs[i] = prhs[i];
    }
    for (; i < 3; ++i) {
        mprhs[i] = NULL;
    }
    mlfEnterNewContext(0, 3, mprhs[0], mprhs[1], mprhs[2]);
    Mrecarga_2_3_Srz_CreateFcn(mprhs[0], mprhs[1], mprhs[2]);
    mlfRestorePreviousContext(0, 3, mprhs[0], mprhs[1], mprhs[2]);
}

/*
 * The function "mlfRecarga_2_3_Srz_Callback" contains the normal interface for
 * the "recarga_2_3/Srz_Callback" M-function from file
 * "u:\final_recarga6\recarga\recarga_2_3.m" (lines 962-972). This function
 * processes any input arguments and passes them to the implementation version
 * of the function, appearing above.
 */
static void mlfRecarga_2_3_Srz_Callback(mxArray * hObject,
                                        mxArray * eventdata,
                                        mxArray * handles) {
    mlfEnterNewContext(0, 3, hObject, eventdata, handles);
    Mrecarga_2_3_Srz_Callback(hObject, eventdata, handles);
    mlfRestorePreviousContext(0, 3, hObject, eventdata, handles);
}

/*
 * The function "mlxRecarga_2_3_Srz_Callback" contains the feval interface for
 * the "recarga_2_3/Srz_Callback" M-function from file
 * "u:\final_recarga6\recarga\recarga_2_3.m" (lines 962-972). The feval
 * function calls the implementation version of recarga_2_3/Srz_Callback
 * through this function. This function processes any input arguments and
 * passes them to the implementation version of the function, appearing above.
 */
static void mlxRecarga_2_3_Srz_Callback(int nlhs,
                                        mxArray * plhs[],
                                        int nrhs,
                                        mxArray * prhs[]) {
    mxArray * mprhs[3];
    int i;
    if (nlhs > 0) {
        mlfError(
          mxCreateString(
            "Run-time Error: File: recarga_2_3/Srz_Callback Line: 962 C"
            "olumn: 1 The function \"recarga_2_3/Srz_Callback\" was cal"
            "led with more than the declared number of outputs (0)."),
          NULL);
    }
    if (nrhs > 3) {
        mlfError(
          mxCreateString(
            "Run-time Error: File: recarga_2_3/Srz_Callback Line: 962 "
            "Column: 1 The function \"recarga_2_3/Srz_Callback\" was c"
            "alled with more than the declared number of inputs (3)."),
          NULL);
    }
    for (i = 0; i < 3 && i < nrhs; ++i) {
        mprhs[i] = prhs[i];
    }
    for (; i < 3; ++i) {
        mprhs[i] = NULL;
    }
    mlfEnterNewContext(0, 3, mprhs[0], mprhs[1], mprhs[2]);
    Mrecarga_2_3_Srz_Callback(mprhs[0], mprhs[1], mprhs[2]);
    mlfRestorePreviousContext(0, 3, mprhs[0], mprhs[1], mprhs[2]);
}

/*
 * The function "mlfRecarga_2_3_St_CreateFcn" contains the normal interface for
 * the "recarga_2_3/St_CreateFcn" M-function from file
 * "u:\final_recarga6\recarga\recarga_2_3.m" (lines 972-987). This function
 * processes any input arguments and passes them to the implementation version
 * of the function, appearing above.
 */
static void mlfRecarga_2_3_St_CreateFcn(mxArray * hObject,
                                        mxArray * eventdata,
                                        mxArray * handles) {
    mlfEnterNewContext(0, 3, hObject, eventdata, handles);
    Mrecarga_2_3_St_CreateFcn(hObject, eventdata, handles);
    mlfRestorePreviousContext(0, 3, hObject, eventdata, handles);
}

/*
 * The function "mlxRecarga_2_3_St_CreateFcn" contains the feval interface for
 * the "recarga_2_3/St_CreateFcn" M-function from file
 * "u:\final_recarga6\recarga\recarga_2_3.m" (lines 972-987). The feval
 * function calls the implementation version of recarga_2_3/St_CreateFcn
 * through this function. This function processes any input arguments and
 * passes them to the implementation version of the function, appearing above.
 */
static void mlxRecarga_2_3_St_CreateFcn(int nlhs,
                                        mxArray * plhs[],
                                        int nrhs,
                                        mxArray * prhs[]) {
    mxArray * mprhs[3];
    int i;
    if (nlhs > 0) {
        mlfError(
          mxCreateString(
            "Run-time Error: File: recarga_2_3/St_CreateFcn Line: 972 C"
            "olumn: 1 The function \"recarga_2_3/St_CreateFcn\" was cal"
            "led with more than the declared number of outputs (0)."),
          NULL);
    }
    if (nrhs > 3) {
        mlfError(
          mxCreateString(
            "Run-time Error: File: recarga_2_3/St_CreateFcn Line: 972 "
            "Column: 1 The function \"recarga_2_3/St_CreateFcn\" was c"
            "alled with more than the declared number of inputs (3)."),
          NULL);
    }
    for (i = 0; i < 3 && i < nrhs; ++i) {
        mprhs[i] = prhs[i];
    }
    for (; i < 3; ++i) {
        mprhs[i] = NULL;
    }
    mlfEnterNewContext(0, 3, mprhs[0], mprhs[1], mprhs[2]);
    Mrecarga_2_3_St_CreateFcn(mprhs[0], mprhs[1], mprhs[2]);
    mlfRestorePreviousContext(0, 3, mprhs[0], mprhs[1], mprhs[2]);
}

/*
 * The function "mlfRecarga_2_3_St_Callback" contains the normal interface for
 * the "recarga_2_3/St_Callback" M-function from file
 * "u:\final_recarga6\recarga\recarga_2_3.m" (lines 987-998). This function
 * processes any input arguments and passes them to the implementation version
 * of the function, appearing above.
 */
static void mlfRecarga_2_3_St_Callback(mxArray * hObject,
                                       mxArray * eventdata,
                                       mxArray * handles) {
    mlfEnterNewContext(0, 3, hObject, eventdata, handles);
    Mrecarga_2_3_St_Callback(hObject, eventdata, handles);
    mlfRestorePreviousContext(0, 3, hObject, eventdata, handles);
}

/*
 * The function "mlxRecarga_2_3_St_Callback" contains the feval interface for
 * the "recarga_2_3/St_Callback" M-function from file
 * "u:\final_recarga6\recarga\recarga_2_3.m" (lines 987-998). The feval
 * function calls the implementation version of recarga_2_3/St_Callback through
 * this function. This function processes any input arguments and passes them
 * to the implementation version of the function, appearing above.
 */
static void mlxRecarga_2_3_St_Callback(int nlhs,
                                       mxArray * plhs[],
                                       int nrhs,
                                       mxArray * prhs[]) {
    mxArray * mprhs[3];
    int i;
    if (nlhs > 0) {
        mlfError(
          mxCreateString(
            "Run-time Error: File: recarga_2_3/St_Callback Line: 987 C"
            "olumn: 1 The function \"recarga_2_3/St_Callback\" was cal"
            "led with more than the declared number of outputs (0)."),
          NULL);
    }
    if (nrhs > 3) {
        mlfError(
          mxCreateString(
            "Run-time Error: File: recarga_2_3/St_Callback Line: 987 C"
            "olumn: 1 The function \"recarga_2_3/St_Callback\" was cal"
            "led with more than the declared number of inputs (3)."),
          NULL);
    }
    for (i = 0; i < 3 && i < nrhs; ++i) {
        mprhs[i] = prhs[i];
    }
    for (; i < 3; ++i) {
        mprhs[i] = NULL;
    }
    mlfEnterNewContext(0, 3, mprhs[0], mprhs[1], mprhs[2]);
    Mrecarga_2_3_St_Callback(mprhs[0], mprhs[1], mprhs[2]);
    mlfRestorePreviousContext(0, 3, mprhs[0], mprhs[1], mprhs[2]);
}

/*
 * The function "mlfRecarga_2_3_Ksat_CreateFcn" contains the normal interface
 * for the "recarga_2_3/Ksat_CreateFcn" M-function from file
 * "u:\final_recarga6\recarga\recarga_2_3.m" (lines 998-1013). This function
 * processes any input arguments and passes them to the implementation version
 * of the function, appearing above.
 */
static void mlfRecarga_2_3_Ksat_CreateFcn(mxArray * hObject,
                                          mxArray * eventdata,
                                          mxArray * handles) {
    mlfEnterNewContext(0, 3, hObject, eventdata, handles);
    Mrecarga_2_3_Ksat_CreateFcn(hObject, eventdata, handles);
    mlfRestorePreviousContext(0, 3, hObject, eventdata, handles);
}

/*
 * The function "mlxRecarga_2_3_Ksat_CreateFcn" contains the feval interface
 * for the "recarga_2_3/Ksat_CreateFcn" M-function from file
 * "u:\final_recarga6\recarga\recarga_2_3.m" (lines 998-1013). The feval
 * function calls the implementation version of recarga_2_3/Ksat_CreateFcn
 * through this function. This function processes any input arguments and
 * passes them to the implementation version of the function, appearing above.
 */
static void mlxRecarga_2_3_Ksat_CreateFcn(int nlhs,
                                          mxArray * plhs[],
                                          int nrhs,
                                          mxArray * prhs[]) {
    mxArray * mprhs[3];
    int i;
    if (nlhs > 0) {
        mlfError(
          mxCreateString(
            "Run-time Error: File: recarga_2_3/Ksat_CreateFcn Line: 998 "
            "Column: 1 The function \"recarga_2_3/Ksat_CreateFcn\" was c"
            "alled with more than the declared number of outputs (0)."),
          NULL);
    }
    if (nrhs > 3) {
        mlfError(
          mxCreateString(
            "Run-time Error: File: recarga_2_3/Ksat_CreateFcn Line: 998 "
            "Column: 1 The function \"recarga_2_3/Ksat_CreateFcn\" was c"
            "alled with more than the declared number of inputs (3)."),
          NULL);
    }
    for (i = 0; i < 3 && i < nrhs; ++i) {
        mprhs[i] = prhs[i];
    }
    for (; i < 3; ++i) {
        mprhs[i] = NULL;
    }
    mlfEnterNewContext(0, 3, mprhs[0], mprhs[1], mprhs[2]);
    Mrecarga_2_3_Ksat_CreateFcn(mprhs[0], mprhs[1], mprhs[2]);
    mlfRestorePreviousContext(0, 3, mprhs[0], mprhs[1], mprhs[2]);
}

/*
 * The function "mlfRecarga_2_3_Ksat_Callback" contains the normal interface
 * for the "recarga_2_3/Ksat_Callback" M-function from file
 * "u:\final_recarga6\recarga\recarga_2_3.m" (lines 1013-1024). This function
 * processes any input arguments and passes them to the implementation version
 * of the function, appearing above.
 */
static void mlfRecarga_2_3_Ksat_Callback(mxArray * hObject,
                                         mxArray * eventdata,
                                         mxArray * handles) {
    mlfEnterNewContext(0, 3, hObject, eventdata, handles);
    Mrecarga_2_3_Ksat_Callback(hObject, eventdata, handles);
    mlfRestorePreviousContext(0, 3, hObject, eventdata, handles);
}

/*
 * The function "mlxRecarga_2_3_Ksat_Callback" contains the feval interface for
 * the "recarga_2_3/Ksat_Callback" M-function from file
 * "u:\final_recarga6\recarga\recarga_2_3.m" (lines 1013-1024). The feval
 * function calls the implementation version of recarga_2_3/Ksat_Callback
 * through this function. This function processes any input arguments and
 * passes them to the implementation version of the function, appearing above.
 */
static void mlxRecarga_2_3_Ksat_Callback(int nlhs,
                                         mxArray * plhs[],
                                         int nrhs,
                                         mxArray * prhs[]) {
    mxArray * mprhs[3];
    int i;
    if (nlhs > 0) {
        mlfError(
          mxCreateString(
            "Run-time Error: File: recarga_2_3/Ksat_Callback Line: 1013 "
            "Column: 1 The function \"recarga_2_3/Ksat_Callback\" was ca"
            "lled with more than the declared number of outputs (0)."),
          NULL);
    }
    if (nrhs > 3) {
        mlfError(
          mxCreateString(
            "Run-time Error: File: recarga_2_3/Ksat_Callback Line: 1013"
            " Column: 1 The function \"recarga_2_3/Ksat_Callback\" was "
            "called with more than the declared number of inputs (3)."),
          NULL);
    }
    for (i = 0; i < 3 && i < nrhs; ++i) {
        mprhs[i] = prhs[i];
    }
    for (; i < 3; ++i) {
        mprhs[i] = NULL;
    }
    mlfEnterNewContext(0, 3, mprhs[0], mprhs[1], mprhs[2]);
    Mrecarga_2_3_Ksat_Callback(mprhs[0], mprhs[1], mprhs[2]);
    mlfRestorePreviousContext(0, 3, mprhs[0], mprhs[1], mprhs[2]);
}

/*
 * The function "mlfRecarga_2_3_Input_CreateFcn" contains the normal interface
 * for the "recarga_2_3/Input_CreateFcn" M-function from file
 * "u:\final_recarga6\recarga\recarga_2_3.m" (lines 1024-1039). This function
 * processes any input arguments and passes them to the implementation version
 * of the function, appearing above.
 */
static void mlfRecarga_2_3_Input_CreateFcn(mxArray * hObject,
                                           mxArray * eventdata,
                                           mxArray * handles) {
    mlfEnterNewContext(0, 3, hObject, eventdata, handles);
    Mrecarga_2_3_Input_CreateFcn(hObject, eventdata, handles);
    mlfRestorePreviousContext(0, 3, hObject, eventdata, handles);
}

/*
 * The function "mlxRecarga_2_3_Input_CreateFcn" contains the feval interface
 * for the "recarga_2_3/Input_CreateFcn" M-function from file
 * "u:\final_recarga6\recarga\recarga_2_3.m" (lines 1024-1039). The feval
 * function calls the implementation version of recarga_2_3/Input_CreateFcn
 * through this function. This function processes any input arguments and
 * passes them to the implementation version of the function, appearing above.
 */
static void mlxRecarga_2_3_Input_CreateFcn(int nlhs,
                                           mxArray * plhs[],
                                           int nrhs,
                                           mxArray * prhs[]) {
    mxArray * mprhs[3];
    int i;
    if (nlhs > 0) {
        mlfError(
          mxCreateString(
            "Run-time Error: File: recarga_2_3/Input_CreateFcn Line: 1024"
            " Column: 1 The function \"recarga_2_3/Input_CreateFcn\" was "
            "called with more than the declared number of outputs (0)."),
          NULL);
    }
    if (nrhs > 3) {
        mlfError(
          mxCreateString(
            "Run-time Error: File: recarga_2_3/Input_CreateFcn Line: 1024"
            " Column: 1 The function \"recarga_2_3/Input_CreateFcn\" was "
            "called with more than the declared number of inputs (3)."),
          NULL);
    }
    for (i = 0; i < 3 && i < nrhs; ++i) {
        mprhs[i] = prhs[i];
    }
    for (; i < 3; ++i) {
        mprhs[i] = NULL;
    }
    mlfEnterNewContext(0, 3, mprhs[0], mprhs[1], mprhs[2]);
    Mrecarga_2_3_Input_CreateFcn(mprhs[0], mprhs[1], mprhs[2]);
    mlfRestorePreviousContext(0, 3, mprhs[0], mprhs[1], mprhs[2]);
}

/*
 * The function "mlfRecarga_2_3_Input_Callback" contains the normal interface
 * for the "recarga_2_3/Input_Callback" M-function from file
 * "u:\final_recarga6\recarga\recarga_2_3.m" (lines 1039-1049). This function
 * processes any input arguments and passes them to the implementation version
 * of the function, appearing above.
 */
static void mlfRecarga_2_3_Input_Callback(mxArray * hObject,
                                          mxArray * eventdata,
                                          mxArray * handles) {
    mlfEnterNewContext(0, 3, hObject, eventdata, handles);
    Mrecarga_2_3_Input_Callback(hObject, eventdata, handles);
    mlfRestorePreviousContext(0, 3, hObject, eventdata, handles);
}

/*
 * The function "mlxRecarga_2_3_Input_Callback" contains the feval interface
 * for the "recarga_2_3/Input_Callback" M-function from file
 * "u:\final_recarga6\recarga\recarga_2_3.m" (lines 1039-1049). The feval
 * function calls the implementation version of recarga_2_3/Input_Callback
 * through this function. This function processes any input arguments and
 * passes them to the implementation version of the function, appearing above.
 */
static void mlxRecarga_2_3_Input_Callback(int nlhs,
                                          mxArray * plhs[],
                                          int nrhs,
                                          mxArray * prhs[]) {
    mxArray * mprhs[3];
    int i;
    if (nlhs > 0) {
        mlfError(
          mxCreateString(
            "Run-time Error: File: recarga_2_3/Input_Callback Line: 1039"
            " Column: 1 The function \"recarga_2_3/Input_Callback\" was "
            "called with more than the declared number of outputs (0)."),
          NULL);
    }
    if (nrhs > 3) {
        mlfError(
          mxCreateString(
            "Run-time Error: File: recarga_2_3/Input_Callback Line: 1039"
            " Column: 1 The function \"recarga_2_3/Input_Callback\" was "
            "called with more than the declared number of inputs (3)."),
          NULL);
    }
    for (i = 0; i < 3 && i < nrhs; ++i) {
        mprhs[i] = prhs[i];
    }
    for (; i < 3; ++i) {
        mprhs[i] = NULL;
    }
    mlfEnterNewContext(0, 3, mprhs[0], mprhs[1], mprhs[2]);
    Mrecarga_2_3_Input_Callback(mprhs[0], mprhs[1], mprhs[2]);
    mlfRestorePreviousContext(0, 3, mprhs[0], mprhs[1], mprhs[2]);
}

/*
 * The function "mlfRecarga_2_3_edit9_CreateFcn" contains the normal interface
 * for the "recarga_2_3/edit9_CreateFcn" M-function from file
 * "u:\final_recarga6\recarga\recarga_2_3.m" (lines 1049-1064). This function
 * processes any input arguments and passes them to the implementation version
 * of the function, appearing above.
 */
static void mlfRecarga_2_3_edit9_CreateFcn(mxArray * hObject,
                                           mxArray * eventdata,
                                           mxArray * handles) {
    mlfEnterNewContext(0, 3, hObject, eventdata, handles);
    Mrecarga_2_3_edit9_CreateFcn(hObject, eventdata, handles);
    mlfRestorePreviousContext(0, 3, hObject, eventdata, handles);
}

/*
 * The function "mlxRecarga_2_3_edit9_CreateFcn" contains the feval interface
 * for the "recarga_2_3/edit9_CreateFcn" M-function from file
 * "u:\final_recarga6\recarga\recarga_2_3.m" (lines 1049-1064). The feval
 * function calls the implementation version of recarga_2_3/edit9_CreateFcn
 * through this function. This function processes any input arguments and
 * passes them to the implementation version of the function, appearing above.
 */
static void mlxRecarga_2_3_edit9_CreateFcn(int nlhs,
                                           mxArray * plhs[],
                                           int nrhs,
                                           mxArray * prhs[]) {
    mxArray * mprhs[3];
    int i;
    if (nlhs > 0) {
        mlfError(
          mxCreateString(
            "Run-time Error: File: recarga_2_3/edit9_CreateFcn Line: 1049"
            " Column: 1 The function \"recarga_2_3/edit9_CreateFcn\" was "
            "called with more than the declared number of outputs (0)."),
          NULL);
    }
    if (nrhs > 3) {
        mlfError(
          mxCreateString(
            "Run-time Error: File: recarga_2_3/edit9_CreateFcn Line: 1049"
            " Column: 1 The function \"recarga_2_3/edit9_CreateFcn\" was "
            "called with more than the declared number of inputs (3)."),
          NULL);
    }
    for (i = 0; i < 3 && i < nrhs; ++i) {
        mprhs[i] = prhs[i];
    }
    for (; i < 3; ++i) {
        mprhs[i] = NULL;
    }
    mlfEnterNewContext(0, 3, mprhs[0], mprhs[1], mprhs[2]);
    Mrecarga_2_3_edit9_CreateFcn(mprhs[0], mprhs[1], mprhs[2]);
    mlfRestorePreviousContext(0, 3, mprhs[0], mprhs[1], mprhs[2]);
}

/*
 * The function "mlfRecarga_2_3_edit9_Callback" contains the normal interface
 * for the "recarga_2_3/edit9_Callback" M-function from file
 * "u:\final_recarga6\recarga\recarga_2_3.m" (lines 1064-1074). This function
 * processes any input arguments and passes them to the implementation version
 * of the function, appearing above.
 */
static void mlfRecarga_2_3_edit9_Callback(mxArray * hObject,
                                          mxArray * eventdata,
                                          mxArray * handles) {
    mlfEnterNewContext(0, 3, hObject, eventdata, handles);
    Mrecarga_2_3_edit9_Callback(hObject, eventdata, handles);
    mlfRestorePreviousContext(0, 3, hObject, eventdata, handles);
}

/*
 * The function "mlxRecarga_2_3_edit9_Callback" contains the feval interface
 * for the "recarga_2_3/edit9_Callback" M-function from file
 * "u:\final_recarga6\recarga\recarga_2_3.m" (lines 1064-1074). The feval
 * function calls the implementation version of recarga_2_3/edit9_Callback
 * through this function. This function processes any input arguments and
 * passes them to the implementation version of the function, appearing above.
 */
static void mlxRecarga_2_3_edit9_Callback(int nlhs,
                                          mxArray * plhs[],
                                          int nrhs,
                                          mxArray * prhs[]) {
    mxArray * mprhs[3];
    int i;
    if (nlhs > 0) {
        mlfError(
          mxCreateString(
            "Run-time Error: File: recarga_2_3/edit9_Callback Line: 1064"
            " Column: 1 The function \"recarga_2_3/edit9_Callback\" was "
            "called with more than the declared number of outputs (0)."),
          NULL);
    }
    if (nrhs > 3) {
        mlfError(
          mxCreateString(
            "Run-time Error: File: recarga_2_3/edit9_Callback Line: 1064"
            " Column: 1 The function \"recarga_2_3/edit9_Callback\" was "
            "called with more than the declared number of inputs (3)."),
          NULL);
    }
    for (i = 0; i < 3 && i < nrhs; ++i) {
        mprhs[i] = prhs[i];
    }
    for (; i < 3; ++i) {
        mprhs[i] = NULL;
    }
    mlfEnterNewContext(0, 3, mprhs[0], mprhs[1], mprhs[2]);
    Mrecarga_2_3_edit9_Callback(mprhs[0], mprhs[1], mprhs[2]);
    mlfRestorePreviousContext(0, 3, mprhs[0], mprhs[1], mprhs[2]);
}

/*
 * The function "mlfRecarga_2_3_popupmenu1_CreateFcn" contains the normal
 * interface for the "recarga_2_3/popupmenu1_CreateFcn" M-function from file
 * "u:\final_recarga6\recarga\recarga_2_3.m" (lines 1074-1089). This function
 * processes any input arguments and passes them to the implementation version
 * of the function, appearing above.
 */
static void mlfRecarga_2_3_popupmenu1_CreateFcn(mxArray * hObject,
                                                mxArray * eventdata,
                                                mxArray * handles) {
    mlfEnterNewContext(0, 3, hObject, eventdata, handles);
    Mrecarga_2_3_popupmenu1_CreateFcn(hObject, eventdata, handles);
    mlfRestorePreviousContext(0, 3, hObject, eventdata, handles);
}

/*
 * The function "mlxRecarga_2_3_popupmenu1_CreateFcn" contains the feval
 * interface for the "recarga_2_3/popupmenu1_CreateFcn" M-function from file
 * "u:\final_recarga6\recarga\recarga_2_3.m" (lines 1074-1089). The feval
 * function calls the implementation version of
 * recarga_2_3/popupmenu1_CreateFcn through this function. This function
 * processes any input arguments and passes them to the implementation version
 * of the function, appearing above.
 */
static void mlxRecarga_2_3_popupmenu1_CreateFcn(int nlhs,
                                                mxArray * plhs[],
                                                int nrhs,
                                                mxArray * prhs[]) {
    mxArray * mprhs[3];
    int i;
    if (nlhs > 0) {
        mlfError(
          mxCreateString(
            "Run-time Error: File: recarga_2_3/popupmenu1_CreateFcn Line: 10"
            "74 Column: 1 The function \"recarga_2_3/popupmenu1_CreateFcn\" "
            "was called with more than the declared number of outputs (0)."),
          NULL);
    }
    if (nrhs > 3) {
        mlfError(
          mxCreateString(
            "Run-time Error: File: recarga_2_3/popupmenu1_CreateFcn Line: 10"
            "74 Column: 1 The function \"recarga_2_3/popupmenu1_CreateFcn\" "
            "was called with more than the declared number of inputs (3)."),
          NULL);
    }
    for (i = 0; i < 3 && i < nrhs; ++i) {
        mprhs[i] = prhs[i];
    }
    for (; i < 3; ++i) {
        mprhs[i] = NULL;
    }
    mlfEnterNewContext(0, 3, mprhs[0], mprhs[1], mprhs[2]);
    Mrecarga_2_3_popupmenu1_CreateFcn(mprhs[0], mprhs[1], mprhs[2]);
    mlfRestorePreviousContext(0, 3, mprhs[0], mprhs[1], mprhs[2]);
}

/*
 * The function "mlfRecarga_2_3_popupmenu1_Callback" contains the normal
 * interface for the "recarga_2_3/popupmenu1_Callback" M-function from file
 * "u:\final_recarga6\recarga\recarga_2_3.m" (lines 1089-1099). This function
 * processes any input arguments and passes them to the implementation version
 * of the function, appearing above.
 */
static void mlfRecarga_2_3_popupmenu1_Callback(mxArray * hObject,
                                               mxArray * eventdata,
                                               mxArray * handles) {
    mlfEnterNewContext(0, 3, hObject, eventdata, handles);
    Mrecarga_2_3_popupmenu1_Callback(hObject, eventdata, handles);
    mlfRestorePreviousContext(0, 3, hObject, eventdata, handles);
}

/*
 * The function "mlxRecarga_2_3_popupmenu1_Callback" contains the feval
 * interface for the "recarga_2_3/popupmenu1_Callback" M-function from file
 * "u:\final_recarga6\recarga\recarga_2_3.m" (lines 1089-1099). The feval
 * function calls the implementation version of recarga_2_3/popupmenu1_Callback
 * through this function. This function processes any input arguments and
 * passes them to the implementation version of the function, appearing above.
 */
static void mlxRecarga_2_3_popupmenu1_Callback(int nlhs,
                                               mxArray * plhs[],
                                               int nrhs,
                                               mxArray * prhs[]) {
    mxArray * mprhs[3];
    int i;
    if (nlhs > 0) {
        mlfError(
          mxCreateString(
            "Run-time Error: File: recarga_2_3/popupmenu1_Callback Line: 108"
            "9 Column: 1 The function \"recarga_2_3/popupmenu1_Callback\" wa"
            "s called with more than the declared number of outputs (0)."),
          NULL);
    }
    if (nrhs > 3) {
        mlfError(
          mxCreateString(
            "Run-time Error: File: recarga_2_3/popupmenu1_Callback Line: 10"
            "89 Column: 1 The function \"recarga_2_3/popupmenu1_Callback\" "
            "was called with more than the declared number of inputs (3)."),
          NULL);
    }
    for (i = 0; i < 3 && i < nrhs; ++i) {
        mprhs[i] = prhs[i];
    }
    for (; i < 3; ++i) {
        mprhs[i] = NULL;
    }
    mlfEnterNewContext(0, 3, mprhs[0], mprhs[1], mprhs[2]);
    Mrecarga_2_3_popupmenu1_Callback(mprhs[0], mprhs[1], mprhs[2]);
    mlfRestorePreviousContext(0, 3, mprhs[0], mprhs[1], mprhs[2]);
}

/*
 * The function "mlfRecarga_2_3_Length_CreateFcn" contains the normal interface
 * for the "recarga_2_3/Length_CreateFcn" M-function from file
 * "u:\final_recarga6\recarga\recarga_2_3.m" (lines 1099-1114). This function
 * processes any input arguments and passes them to the implementation version
 * of the function, appearing above.
 */
static void mlfRecarga_2_3_Length_CreateFcn(mxArray * hObject,
                                            mxArray * eventdata,
                                            mxArray * handles) {
    mlfEnterNewContext(0, 3, hObject, eventdata, handles);
    Mrecarga_2_3_Length_CreateFcn(hObject, eventdata, handles);
    mlfRestorePreviousContext(0, 3, hObject, eventdata, handles);
}

/*
 * The function "mlxRecarga_2_3_Length_CreateFcn" contains the feval interface
 * for the "recarga_2_3/Length_CreateFcn" M-function from file
 * "u:\final_recarga6\recarga\recarga_2_3.m" (lines 1099-1114). The feval
 * function calls the implementation version of recarga_2_3/Length_CreateFcn
 * through this function. This function processes any input arguments and
 * passes them to the implementation version of the function, appearing above.
 */
static void mlxRecarga_2_3_Length_CreateFcn(int nlhs,
                                            mxArray * plhs[],
                                            int nrhs,
                                            mxArray * prhs[]) {
    mxArray * mprhs[3];
    int i;
    if (nlhs > 0) {
        mlfError(
          mxCreateString(
            "Run-time Error: File: recarga_2_3/Length_CreateFcn Line: 1099"
            " Column: 1 The function \"recarga_2_3/Length_CreateFcn\" was "
            "called with more than the declared number of outputs (0)."),
          NULL);
    }
    if (nrhs > 3) {
        mlfError(
          mxCreateString(
            "Run-time Error: File: recarga_2_3/Length_CreateFcn Line: 109"
            "9 Column: 1 The function \"recarga_2_3/Length_CreateFcn\" wa"
            "s called with more than the declared number of inputs (3)."),
          NULL);
    }
    for (i = 0; i < 3 && i < nrhs; ++i) {
        mprhs[i] = prhs[i];
    }
    for (; i < 3; ++i) {
        mprhs[i] = NULL;
    }
    mlfEnterNewContext(0, 3, mprhs[0], mprhs[1], mprhs[2]);
    Mrecarga_2_3_Length_CreateFcn(mprhs[0], mprhs[1], mprhs[2]);
    mlfRestorePreviousContext(0, 3, mprhs[0], mprhs[1], mprhs[2]);
}

/*
 * The function "mlfRecarga_2_3_Length_Callback" contains the normal interface
 * for the "recarga_2_3/Length_Callback" M-function from file
 * "u:\final_recarga6\recarga\recarga_2_3.m" (lines 1114-1124). This function
 * processes any input arguments and passes them to the implementation version
 * of the function, appearing above.
 */
static void mlfRecarga_2_3_Length_Callback(mxArray * hObject,
                                           mxArray * eventdata,
                                           mxArray * handles) {
    mlfEnterNewContext(0, 3, hObject, eventdata, handles);
    Mrecarga_2_3_Length_Callback(hObject, eventdata, handles);
    mlfRestorePreviousContext(0, 3, hObject, eventdata, handles);
}

/*
 * The function "mlxRecarga_2_3_Length_Callback" contains the feval interface
 * for the "recarga_2_3/Length_Callback" M-function from file
 * "u:\final_recarga6\recarga\recarga_2_3.m" (lines 1114-1124). The feval
 * function calls the implementation version of recarga_2_3/Length_Callback
 * through this function. This function processes any input arguments and
 * passes them to the implementation version of the function, appearing above.
 */
static void mlxRecarga_2_3_Length_Callback(int nlhs,
                                           mxArray * plhs[],
                                           int nrhs,
                                           mxArray * prhs[]) {
    mxArray * mprhs[3];
    int i;
    if (nlhs > 0) {
        mlfError(
          mxCreateString(
            "Run-time Error: File: recarga_2_3/Length_Callback Line: 1114"
            " Column: 1 The function \"recarga_2_3/Length_Callback\" was "
            "called with more than the declared number of outputs (0)."),
          NULL);
    }
    if (nrhs > 3) {
        mlfError(
          mxCreateString(
            "Run-time Error: File: recarga_2_3/Length_Callback Line: 1114"
            " Column: 1 The function \"recarga_2_3/Length_Callback\" was "
            "called with more than the declared number of inputs (3)."),
          NULL);
    }
    for (i = 0; i < 3 && i < nrhs; ++i) {
        mprhs[i] = prhs[i];
    }
    for (; i < 3; ++i) {
        mprhs[i] = NULL;
    }
    mlfEnterNewContext(0, 3, mprhs[0], mprhs[1], mprhs[2]);
    Mrecarga_2_3_Length_Callback(mprhs[0], mprhs[1], mprhs[2]);
    mlfRestorePreviousContext(0, 3, mprhs[0], mprhs[1], mprhs[2]);
}

/*
 * The function "mlfRecarga_2_3_Output_CreateFcn" contains the normal interface
 * for the "recarga_2_3/Output_CreateFcn" M-function from file
 * "u:\final_recarga6\recarga\recarga_2_3.m" (lines 1124-1139). This function
 * processes any input arguments and passes them to the implementation version
 * of the function, appearing above.
 */
static void mlfRecarga_2_3_Output_CreateFcn(mxArray * hObject,
                                            mxArray * eventdata,
                                            mxArray * handles) {
    mlfEnterNewContext(0, 3, hObject, eventdata, handles);
    Mrecarga_2_3_Output_CreateFcn(hObject, eventdata, handles);
    mlfRestorePreviousContext(0, 3, hObject, eventdata, handles);
}

/*
 * The function "mlxRecarga_2_3_Output_CreateFcn" contains the feval interface
 * for the "recarga_2_3/Output_CreateFcn" M-function from file
 * "u:\final_recarga6\recarga\recarga_2_3.m" (lines 1124-1139). The feval
 * function calls the implementation version of recarga_2_3/Output_CreateFcn
 * through this function. This function processes any input arguments and
 * passes them to the implementation version of the function, appearing above.
 */
static void mlxRecarga_2_3_Output_CreateFcn(int nlhs,
                                            mxArray * plhs[],
                                            int nrhs,
                                            mxArray * prhs[]) {
    mxArray * mprhs[3];
    int i;
    if (nlhs > 0) {
        mlfError(
          mxCreateString(
            "Run-time Error: File: recarga_2_3/Output_CreateFcn Line: 1124"
            " Column: 1 The function \"recarga_2_3/Output_CreateFcn\" was "
            "called with more than the declared number of outputs (0)."),
          NULL);
    }
    if (nrhs > 3) {
        mlfError(
          mxCreateString(
            "Run-time Error: File: recarga_2_3/Output_CreateFcn Line: 112"
            "4 Column: 1 The function \"recarga_2_3/Output_CreateFcn\" wa"
            "s called with more than the declared number of inputs (3)."),
          NULL);
    }
    for (i = 0; i < 3 && i < nrhs; ++i) {
        mprhs[i] = prhs[i];
    }
    for (; i < 3; ++i) {
        mprhs[i] = NULL;
    }
    mlfEnterNewContext(0, 3, mprhs[0], mprhs[1], mprhs[2]);
    Mrecarga_2_3_Output_CreateFcn(mprhs[0], mprhs[1], mprhs[2]);
    mlfRestorePreviousContext(0, 3, mprhs[0], mprhs[1], mprhs[2]);
}

/*
 * The function "mlfRecarga_2_3_Output_Callback" contains the normal interface
 * for the "recarga_2_3/Output_Callback" M-function from file
 * "u:\final_recarga6\recarga\recarga_2_3.m" (lines 1139-1149). This function
 * processes any input arguments and passes them to the implementation version
 * of the function, appearing above.
 */
static void mlfRecarga_2_3_Output_Callback(mxArray * hObject,
                                           mxArray * eventdata,
                                           mxArray * handles) {
    mlfEnterNewContext(0, 3, hObject, eventdata, handles);
    Mrecarga_2_3_Output_Callback(hObject, eventdata, handles);
    mlfRestorePreviousContext(0, 3, hObject, eventdata, handles);
}

/*
 * The function "mlxRecarga_2_3_Output_Callback" contains the feval interface
 * for the "recarga_2_3/Output_Callback" M-function from file
 * "u:\final_recarga6\recarga\recarga_2_3.m" (lines 1139-1149). The feval
 * function calls the implementation version of recarga_2_3/Output_Callback
 * through this function. This function processes any input arguments and
 * passes them to the implementation version of the function, appearing above.
 */
static void mlxRecarga_2_3_Output_Callback(int nlhs,
                                           mxArray * plhs[],
                                           int nrhs,
                                           mxArray * prhs[]) {
    mxArray * mprhs[3];
    int i;
    if (nlhs > 0) {
        mlfError(
          mxCreateString(
            "Run-time Error: File: recarga_2_3/Output_Callback Line: 1139"
            " Column: 1 The function \"recarga_2_3/Output_Callback\" was "
            "called with more than the declared number of outputs (0)."),
          NULL);
    }
    if (nrhs > 3) {
        mlfError(
          mxCreateString(
            "Run-time Error: File: recarga_2_3/Output_Callback Line: 1139"
            " Column: 1 The function \"recarga_2_3/Output_Callback\" was "
            "called with more than the declared number of inputs (3)."),
          NULL);
    }
    for (i = 0; i < 3 && i < nrhs; ++i) {
        mprhs[i] = prhs[i];
    }
    for (; i < 3; ++i) {
        mprhs[i] = NULL;
    }
    mlfEnterNewContext(0, 3, mprhs[0], mprhs[1], mprhs[2]);
    Mrecarga_2_3_Output_Callback(mprhs[0], mprhs[1], mprhs[2]);
    mlfRestorePreviousContext(0, 3, mprhs[0], mprhs[1], mprhs[2]);
}

/*
 * The function "mlfRecarga_2_3_Name_CreateFcn" contains the normal interface
 * for the "recarga_2_3/Name_CreateFcn" M-function from file
 * "u:\final_recarga6\recarga\recarga_2_3.m" (lines 1149-1164). This function
 * processes any input arguments and passes them to the implementation version
 * of the function, appearing above.
 */
static void mlfRecarga_2_3_Name_CreateFcn(mxArray * hObject,
                                          mxArray * eventdata,
                                          mxArray * handles) {
    mlfEnterNewContext(0, 3, hObject, eventdata, handles);
    Mrecarga_2_3_Name_CreateFcn(hObject, eventdata, handles);
    mlfRestorePreviousContext(0, 3, hObject, eventdata, handles);
}

/*
 * The function "mlxRecarga_2_3_Name_CreateFcn" contains the feval interface
 * for the "recarga_2_3/Name_CreateFcn" M-function from file
 * "u:\final_recarga6\recarga\recarga_2_3.m" (lines 1149-1164). The feval
 * function calls the implementation version of recarga_2_3/Name_CreateFcn
 * through this function. This function processes any input arguments and
 * passes them to the implementation version of the function, appearing above.
 */
static void mlxRecarga_2_3_Name_CreateFcn(int nlhs,
                                          mxArray * plhs[],
                                          int nrhs,
                                          mxArray * prhs[]) {
    mxArray * mprhs[3];
    int i;
    if (nlhs > 0) {
        mlfError(
          mxCreateString(
            "Run-time Error: File: recarga_2_3/Name_CreateFcn Line: 1149"
            " Column: 1 The function \"recarga_2_3/Name_CreateFcn\" was "
            "called with more than the declared number of outputs (0)."),
          NULL);
    }
    if (nrhs > 3) {
        mlfError(
          mxCreateString(
            "Run-time Error: File: recarga_2_3/Name_CreateFcn Line: 1149"
            " Column: 1 The function \"recarga_2_3/Name_CreateFcn\" was "
            "called with more than the declared number of inputs (3)."),
          NULL);
    }
    for (i = 0; i < 3 && i < nrhs; ++i) {
        mprhs[i] = prhs[i];
    }
    for (; i < 3; ++i) {
        mprhs[i] = NULL;
    }
    mlfEnterNewContext(0, 3, mprhs[0], mprhs[1], mprhs[2]);
    Mrecarga_2_3_Name_CreateFcn(mprhs[0], mprhs[1], mprhs[2]);
    mlfRestorePreviousContext(0, 3, mprhs[0], mprhs[1], mprhs[2]);
}

/*
 * The function "mlfRecarga_2_3_Name_Callback" contains the normal interface
 * for the "recarga_2_3/Name_Callback" M-function from file
 * "u:\final_recarga6\recarga\recarga_2_3.m" (lines 1164-1176). This function
 * processes any input arguments and passes them to the implementation version
 * of the function, appearing above.
 */
static void mlfRecarga_2_3_Name_Callback(mxArray * hObject,
                                         mxArray * eventdata,
                                         mxArray * handles) {
    mlfEnterNewContext(0, 3, hObject, eventdata, handles);
    Mrecarga_2_3_Name_Callback(hObject, eventdata, handles);
    mlfRestorePreviousContext(0, 3, hObject, eventdata, handles);
}

/*
 * The function "mlxRecarga_2_3_Name_Callback" contains the feval interface for
 * the "recarga_2_3/Name_Callback" M-function from file
 * "u:\final_recarga6\recarga\recarga_2_3.m" (lines 1164-1176). The feval
 * function calls the implementation version of recarga_2_3/Name_Callback
 * through this function. This function processes any input arguments and
 * passes them to the implementation version of the function, appearing above.
 */
static void mlxRecarga_2_3_Name_Callback(int nlhs,
                                         mxArray * plhs[],
                                         int nrhs,
                                         mxArray * prhs[]) {
    mxArray * mprhs[3];
    int i;
    if (nlhs > 0) {
        mlfError(
          mxCreateString(
            "Run-time Error: File: recarga_2_3/Name_Callback Line: 1164 "
            "Column: 1 The function \"recarga_2_3/Name_Callback\" was ca"
            "lled with more than the declared number of outputs (0)."),
          NULL);
    }
    if (nrhs > 3) {
        mlfError(
          mxCreateString(
            "Run-time Error: File: recarga_2_3/Name_Callback Line: 1164"
            " Column: 1 The function \"recarga_2_3/Name_Callback\" was "
            "called with more than the declared number of inputs (3)."),
          NULL);
    }
    for (i = 0; i < 3 && i < nrhs; ++i) {
        mprhs[i] = prhs[i];
    }
    for (; i < 3; ++i) {
        mprhs[i] = NULL;
    }
    mlfEnterNewContext(0, 3, mprhs[0], mprhs[1], mprhs[2]);
    Mrecarga_2_3_Name_Callback(mprhs[0], mprhs[1], mprhs[2]);
    mlfRestorePreviousContext(0, 3, mprhs[0], mprhs[1], mprhs[2]);
}

/*
 * The function "mlfRecarga_2_3_RGArea_CreateFcn" contains the normal interface
 * for the "recarga_2_3/RGArea_CreateFcn" M-function from file
 * "u:\final_recarga6\recarga\recarga_2_3.m" (lines 1176-1192). This function
 * processes any input arguments and passes them to the implementation version
 * of the function, appearing above.
 */
static void mlfRecarga_2_3_RGArea_CreateFcn(mxArray * hObject,
                                            mxArray * eventdata,
                                            mxArray * handles) {
    mlfEnterNewContext(0, 3, hObject, eventdata, handles);
    Mrecarga_2_3_RGArea_CreateFcn(hObject, eventdata, handles);
    mlfRestorePreviousContext(0, 3, hObject, eventdata, handles);
}

/*
 * The function "mlxRecarga_2_3_RGArea_CreateFcn" contains the feval interface
 * for the "recarga_2_3/RGArea_CreateFcn" M-function from file
 * "u:\final_recarga6\recarga\recarga_2_3.m" (lines 1176-1192). The feval
 * function calls the implementation version of recarga_2_3/RGArea_CreateFcn
 * through this function. This function processes any input arguments and
 * passes them to the implementation version of the function, appearing above.
 */
static void mlxRecarga_2_3_RGArea_CreateFcn(int nlhs,
                                            mxArray * plhs[],
                                            int nrhs,
                                            mxArray * prhs[]) {
    mxArray * mprhs[3];
    int i;
    if (nlhs > 0) {
        mlfError(
          mxCreateString(
            "Run-time Error: File: recarga_2_3/RGArea_CreateFcn Line: 1176"
            " Column: 1 The function \"recarga_2_3/RGArea_CreateFcn\" was "
            "called with more than the declared number of outputs (0)."),
          NULL);
    }
    if (nrhs > 3) {
        mlfError(
          mxCreateString(
            "Run-time Error: File: recarga_2_3/RGArea_CreateFcn Line: 117"
            "6 Column: 1 The function \"recarga_2_3/RGArea_CreateFcn\" wa"
            "s called with more than the declared number of inputs (3)."),
          NULL);
    }
    for (i = 0; i < 3 && i < nrhs; ++i) {
        mprhs[i] = prhs[i];
    }
    for (; i < 3; ++i) {
        mprhs[i] = NULL;
    }
    mlfEnterNewContext(0, 3, mprhs[0], mprhs[1], mprhs[2]);
    Mrecarga_2_3_RGArea_CreateFcn(mprhs[0], mprhs[1], mprhs[2]);
    mlfRestorePreviousContext(0, 3, mprhs[0], mprhs[1], mprhs[2]);
}

/*
 * The function "mlfRecarga_2_3_RGArea_Callback" contains the normal interface
 * for the "recarga_2_3/RGArea_Callback" M-function from file
 * "u:\final_recarga6\recarga\recarga_2_3.m" (lines 1192-1220). This function
 * processes any input arguments and passes them to the implementation version
 * of the function, appearing above.
 */
static void mlfRecarga_2_3_RGArea_Callback(mxArray * hObject,
                                           mxArray * eventdata,
                                           mxArray * handles) {
    mlfEnterNewContext(0, 3, hObject, eventdata, handles);
    Mrecarga_2_3_RGArea_Callback(hObject, eventdata, handles);
    mlfRestorePreviousContext(0, 3, hObject, eventdata, handles);
}

/*
 * The function "mlxRecarga_2_3_RGArea_Callback" contains the feval interface
 * for the "recarga_2_3/RGArea_Callback" M-function from file
 * "u:\final_recarga6\recarga\recarga_2_3.m" (lines 1192-1220). The feval
 * function calls the implementation version of recarga_2_3/RGArea_Callback
 * through this function. This function processes any input arguments and
 * passes them to the implementation version of the function, appearing above.
 */
static void mlxRecarga_2_3_RGArea_Callback(int nlhs,
                                           mxArray * plhs[],
                                           int nrhs,
                                           mxArray * prhs[]) {
    mxArray * mprhs[3];
    int i;
    if (nlhs > 0) {
        mlfError(
          mxCreateString(
            "Run-time Error: File: recarga_2_3/RGArea_Callback Line: 1192"
            " Column: 1 The function \"recarga_2_3/RGArea_Callback\" was "
            "called with more than the declared number of outputs (0)."),
          NULL);
    }
    if (nrhs > 3) {
        mlfError(
          mxCreateString(
            "Run-time Error: File: recarga_2_3/RGArea_Callback Line: 1192"
            " Column: 1 The function \"recarga_2_3/RGArea_Callback\" was "
            "called with more than the declared number of inputs (3)."),
          NULL);
    }
    for (i = 0; i < 3 && i < nrhs; ++i) {
        mprhs[i] = prhs[i];
    }
    for (; i < 3; ++i) {
        mprhs[i] = NULL;
    }
    mlfEnterNewContext(0, 3, mprhs[0], mprhs[1], mprhs[2]);
    Mrecarga_2_3_RGArea_Callback(mprhs[0], mprhs[1], mprhs[2]);
    mlfRestorePreviousContext(0, 3, mprhs[0], mprhs[1], mprhs[2]);
}

/*
 * The function "mlfRecarga_2_3_RGCalc_Callback" contains the normal interface
 * for the "recarga_2_3/RGCalc_Callback" M-function from file
 * "u:\final_recarga6\recarga\recarga_2_3.m" (lines 1220-1370). This function
 * processes any input arguments and passes them to the implementation version
 * of the function, appearing above.
 */
static void mlfRecarga_2_3_RGCalc_Callback(mxArray * hObject,
                                           mxArray * eventdata,
                                           mxArray * handles) {
    mlfEnterNewContext(0, 3, hObject, eventdata, handles);
    Mrecarga_2_3_RGCalc_Callback(hObject, eventdata, handles);
    mlfRestorePreviousContext(0, 3, hObject, eventdata, handles);
}

/*
 * The function "mlxRecarga_2_3_RGCalc_Callback" contains the feval interface
 * for the "recarga_2_3/RGCalc_Callback" M-function from file
 * "u:\final_recarga6\recarga\recarga_2_3.m" (lines 1220-1370). The feval
 * function calls the implementation version of recarga_2_3/RGCalc_Callback
 * through this function. This function processes any input arguments and
 * passes them to the implementation version of the function, appearing above.
 */
static void mlxRecarga_2_3_RGCalc_Callback(int nlhs,
                                           mxArray * plhs[],
                                           int nrhs,
                                           mxArray * prhs[]) {
    mxArray * mprhs[3];
    int i;
    if (nlhs > 0) {
        mlfError(
          mxCreateString(
            "Run-time Error: File: recarga_2_3/RGCalc_Callback Line: 1220"
            " Column: 1 The function \"recarga_2_3/RGCalc_Callback\" was "
            "called with more than the declared number of outputs (0)."),
          NULL);
    }
    if (nrhs > 3) {
        mlfError(
          mxCreateString(
            "Run-time Error: File: recarga_2_3/RGCalc_Callback Line: 1220"
            " Column: 1 The function \"recarga_2_3/RGCalc_Callback\" was "
            "called with more than the declared number of inputs (3)."),
          NULL);
    }
    for (i = 0; i < 3 && i < nrhs; ++i) {
        mprhs[i] = prhs[i];
    }
    for (; i < 3; ++i) {
        mprhs[i] = NULL;
    }
    mlfEnterNewContext(0, 3, mprhs[0], mprhs[1], mprhs[2]);
    Mrecarga_2_3_RGCalc_Callback(mprhs[0], mprhs[1], mprhs[2]);
    mlfRestorePreviousContext(0, 3, mprhs[0], mprhs[1], mprhs[2]);
}

/*
 * The function "mlfRecarga_2_3_Process_CreateFcn" contains the normal
 * interface for the "recarga_2_3/Process_CreateFcn" M-function from file
 * "u:\final_recarga6\recarga\recarga_2_3.m" (lines 1370-1383). This function
 * processes any input arguments and passes them to the implementation version
 * of the function, appearing above.
 */
static void mlfRecarga_2_3_Process_CreateFcn(mxArray * hObject,
                                             mxArray * eventdata,
                                             mxArray * handles) {
    mlfEnterNewContext(0, 3, hObject, eventdata, handles);
    Mrecarga_2_3_Process_CreateFcn(hObject, eventdata, handles);
    mlfRestorePreviousContext(0, 3, hObject, eventdata, handles);
}

/*
 * The function "mlxRecarga_2_3_Process_CreateFcn" contains the feval interface
 * for the "recarga_2_3/Process_CreateFcn" M-function from file
 * "u:\final_recarga6\recarga\recarga_2_3.m" (lines 1370-1383). The feval
 * function calls the implementation version of recarga_2_3/Process_CreateFcn
 * through this function. This function processes any input arguments and
 * passes them to the implementation version of the function, appearing above.
 */
static void mlxRecarga_2_3_Process_CreateFcn(int nlhs,
                                             mxArray * plhs[],
                                             int nrhs,
                                             mxArray * prhs[]) {
    mxArray * mprhs[3];
    int i;
    if (nlhs > 0) {
        mlfError(
          mxCreateString(
            "Run-time Error: File: recarga_2_3/Process_CreateFcn Line: 137"
            "0 Column: 1 The function \"recarga_2_3/Process_CreateFcn\" wa"
            "s called with more than the declared number of outputs (0)."),
          NULL);
    }
    if (nrhs > 3) {
        mlfError(
          mxCreateString(
            "Run-time Error: File: recarga_2_3/Process_CreateFcn Line: 137"
            "0 Column: 1 The function \"recarga_2_3/Process_CreateFcn\" wa"
            "s called with more than the declared number of inputs (3)."),
          NULL);
    }
    for (i = 0; i < 3 && i < nrhs; ++i) {
        mprhs[i] = prhs[i];
    }
    for (; i < 3; ++i) {
        mprhs[i] = NULL;
    }
    mlfEnterNewContext(0, 3, mprhs[0], mprhs[1], mprhs[2]);
    Mrecarga_2_3_Process_CreateFcn(mprhs[0], mprhs[1], mprhs[2]);
    mlfRestorePreviousContext(0, 3, mprhs[0], mprhs[1], mprhs[2]);
}

/*
 * The function "mlfRecarga_2_3_clear_Callback" contains the normal interface
 * for the "recarga_2_3/clear_Callback" M-function from file
 * "u:\final_recarga6\recarga\recarga_2_3.m" (lines 1383-1409). This function
 * processes any input arguments and passes them to the implementation version
 * of the function, appearing above.
 */
static void mlfRecarga_2_3_clear_Callback(mxArray * hObject,
                                          mxArray * eventdata,
                                          mxArray * handles) {
    mlfEnterNewContext(0, 3, hObject, eventdata, handles);
    Mrecarga_2_3_clear_Callback(hObject, eventdata, handles);
    mlfRestorePreviousContext(0, 3, hObject, eventdata, handles);
}

/*
 * The function "mlxRecarga_2_3_clear_Callback" contains the feval interface
 * for the "recarga_2_3/clear_Callback" M-function from file
 * "u:\final_recarga6\recarga\recarga_2_3.m" (lines 1383-1409). The feval
 * function calls the implementation version of recarga_2_3/clear_Callback
 * through this function. This function processes any input arguments and
 * passes them to the implementation version of the function, appearing above.
 */
static void mlxRecarga_2_3_clear_Callback(int nlhs,
                                          mxArray * plhs[],
                                          int nrhs,
                                          mxArray * prhs[]) {
    mxArray * mprhs[3];
    int i;
    if (nlhs > 0) {
        mlfError(
          mxCreateString(
            "Run-time Error: File: recarga_2_3/clear_Callback Line: 1383"
            " Column: 1 The function \"recarga_2_3/clear_Callback\" was "
            "called with more than the declared number of outputs (0)."),
          NULL);
    }
    if (nrhs > 3) {
        mlfError(
          mxCreateString(
            "Run-time Error: File: recarga_2_3/clear_Callback Line: 1383"
            " Column: 1 The function \"recarga_2_3/clear_Callback\" was "
            "called with more than the declared number of inputs (3)."),
          NULL);
    }
    for (i = 0; i < 3 && i < nrhs; ++i) {
        mprhs[i] = prhs[i];
    }
    for (; i < 3; ++i) {
        mprhs[i] = NULL;
    }
    mlfEnterNewContext(0, 3, mprhs[0], mprhs[1], mprhs[2]);
    Mrecarga_2_3_clear_Callback(mprhs[0], mprhs[1], mprhs[2]);
    mlfRestorePreviousContext(0, 3, mprhs[0], mprhs[1], mprhs[2]);
}

/*
 * The function "mlfRecarga_2_3_RootTexture_CreateFcn" contains the normal
 * interface for the "recarga_2_3/RootTexture_CreateFcn" M-function from file
 * "u:\final_recarga6\recarga\recarga_2_3.m" (lines 1409-1424). This function
 * processes any input arguments and passes them to the implementation version
 * of the function, appearing above.
 */
static void mlfRecarga_2_3_RootTexture_CreateFcn(mxArray * hObject,
                                                 mxArray * eventdata,
                                                 mxArray * handles) {
    mlfEnterNewContext(0, 3, hObject, eventdata, handles);
    Mrecarga_2_3_RootTexture_CreateFcn(hObject, eventdata, handles);
    mlfRestorePreviousContext(0, 3, hObject, eventdata, handles);
}

/*
 * The function "mlxRecarga_2_3_RootTexture_CreateFcn" contains the feval
 * interface for the "recarga_2_3/RootTexture_CreateFcn" M-function from file
 * "u:\final_recarga6\recarga\recarga_2_3.m" (lines 1409-1424). The feval
 * function calls the implementation version of
 * recarga_2_3/RootTexture_CreateFcn through this function. This function
 * processes any input arguments and passes them to the implementation version
 * of the function, appearing above.
 */
static void mlxRecarga_2_3_RootTexture_CreateFcn(int nlhs,
                                                 mxArray * plhs[],
                                                 int nrhs,
                                                 mxArray * prhs[]) {
    mxArray * mprhs[3];
    int i;
    if (nlhs > 0) {
        mlfError(
          mxCreateString(
            "Run-time Error: File: recarga_2_3/RootTexture_CreateFcn Line: 14"
            "09 Column: 1 The function \"recarga_2_3/RootTexture_CreateFcn\" "
            "was called with more than the declared number of outputs (0)."),
          NULL);
    }
    if (nrhs > 3) {
        mlfError(
          mxCreateString(
            "Run-time Error: File: recarga_2_3/RootTexture_CreateFcn Line: 14"
            "09 Column: 1 The function \"recarga_2_3/RootTexture_CreateFcn\" "
            "was called with more than the declared number of inputs (3)."),
          NULL);
    }
    for (i = 0; i < 3 && i < nrhs; ++i) {
        mprhs[i] = prhs[i];
    }
    for (; i < 3; ++i) {
        mprhs[i] = NULL;
    }
    mlfEnterNewContext(0, 3, mprhs[0], mprhs[1], mprhs[2]);
    Mrecarga_2_3_RootTexture_CreateFcn(mprhs[0], mprhs[1], mprhs[2]);
    mlfRestorePreviousContext(0, 3, mprhs[0], mprhs[1], mprhs[2]);
}

/*
 * The function "mlfRecarga_2_3_RootTexture_Callback" contains the normal
 * interface for the "recarga_2_3/RootTexture_Callback" M-function from file
 * "u:\final_recarga6\recarga\recarga_2_3.m" (lines 1424-1434). This function
 * processes any input arguments and passes them to the implementation version
 * of the function, appearing above.
 */
static void mlfRecarga_2_3_RootTexture_Callback(mxArray * hObject,
                                                mxArray * eventdata,
                                                mxArray * handles) {
    mlfEnterNewContext(0, 3, hObject, eventdata, handles);
    Mrecarga_2_3_RootTexture_Callback(hObject, eventdata, handles);
    mlfRestorePreviousContext(0, 3, hObject, eventdata, handles);
}

/*
 * The function "mlxRecarga_2_3_RootTexture_Callback" contains the feval
 * interface for the "recarga_2_3/RootTexture_Callback" M-function from file
 * "u:\final_recarga6\recarga\recarga_2_3.m" (lines 1424-1434). The feval
 * function calls the implementation version of
 * recarga_2_3/RootTexture_Callback through this function. This function
 * processes any input arguments and passes them to the implementation version
 * of the function, appearing above.
 */
static void mlxRecarga_2_3_RootTexture_Callback(int nlhs,
                                                mxArray * plhs[],
                                                int nrhs,
                                                mxArray * prhs[]) {
    mxArray * mprhs[3];
    int i;
    if (nlhs > 0) {
        mlfError(
          mxCreateString(
            "Run-time Error: File: recarga_2_3/RootTexture_Callback Line: 14"
            "24 Column: 1 The function \"recarga_2_3/RootTexture_Callback\" "
            "was called with more than the declared number of outputs (0)."),
          NULL);
    }
    if (nrhs > 3) {
        mlfError(
          mxCreateString(
            "Run-time Error: File: recarga_2_3/RootTexture_Callback Line: 14"
            "24 Column: 1 The function \"recarga_2_3/RootTexture_Callback\" "
            "was called with more than the declared number of inputs (3)."),
          NULL);
    }
    for (i = 0; i < 3 && i < nrhs; ++i) {
        mprhs[i] = prhs[i];
    }
    for (; i < 3; ++i) {
        mprhs[i] = NULL;
    }
    mlfEnterNewContext(0, 3, mprhs[0], mprhs[1], mprhs[2]);
    Mrecarga_2_3_RootTexture_Callback(mprhs[0], mprhs[1], mprhs[2]);
    mlfRestorePreviousContext(0, 3, mprhs[0], mprhs[1], mprhs[2]);
}

/*
 * The function "mlfRecarga_2_3_StorageTexture_CreateFcn" contains the normal
 * interface for the "recarga_2_3/StorageTexture_CreateFcn" M-function from
 * file "u:\final_recarga6\recarga\recarga_2_3.m" (lines 1434-1449). This
 * function processes any input arguments and passes them to the implementation
 * version of the function, appearing above.
 */
static void mlfRecarga_2_3_StorageTexture_CreateFcn(mxArray * hObject,
                                                    mxArray * eventdata,
                                                    mxArray * handles) {
    mlfEnterNewContext(0, 3, hObject, eventdata, handles);
    Mrecarga_2_3_StorageTexture_CreateFcn(hObject, eventdata, handles);
    mlfRestorePreviousContext(0, 3, hObject, eventdata, handles);
}

/*
 * The function "mlxRecarga_2_3_StorageTexture_CreateFcn" contains the feval
 * interface for the "recarga_2_3/StorageTexture_CreateFcn" M-function from
 * file "u:\final_recarga6\recarga\recarga_2_3.m" (lines 1434-1449). The feval
 * function calls the implementation version of
 * recarga_2_3/StorageTexture_CreateFcn through this function. This function
 * processes any input arguments and passes them to the implementation version
 * of the function, appearing above.
 */
static void mlxRecarga_2_3_StorageTexture_CreateFcn(int nlhs,
                                                    mxArray * plhs[],
                                                    int nrhs,
                                                    mxArray * prhs[]) {
    mxArray * mprhs[3];
    int i;
    if (nlhs > 0) {
        mlfError(
          mxCreateString(
            "Run-time Error: File: recarga_2_3/StorageTexture_CreateFcn Line: 1"
            "434 Column: 1 The function \"recarga_2_3/StorageTexture_CreateFcn"
            "\" was called with more than the declared number of outputs (0)."),
          NULL);
    }
    if (nrhs > 3) {
        mlfError(
          mxCreateString(
            "Run-time Error: File: recarga_2_3/StorageTexture_CreateFcn Line: 1"
            "434 Column: 1 The function \"recarga_2_3/StorageTexture_CreateFcn"
            "\" was called with more than the declared number of inputs (3)."),
          NULL);
    }
    for (i = 0; i < 3 && i < nrhs; ++i) {
        mprhs[i] = prhs[i];
    }
    for (; i < 3; ++i) {
        mprhs[i] = NULL;
    }
    mlfEnterNewContext(0, 3, mprhs[0], mprhs[1], mprhs[2]);
    Mrecarga_2_3_StorageTexture_CreateFcn(mprhs[0], mprhs[1], mprhs[2]);
    mlfRestorePreviousContext(0, 3, mprhs[0], mprhs[1], mprhs[2]);
}

/*
 * The function "mlfRecarga_2_3_StorageTexture_Callback" contains the normal
 * interface for the "recarga_2_3/StorageTexture_Callback" M-function from file
 * "u:\final_recarga6\recarga\recarga_2_3.m" (lines 1449-1459). This function
 * processes any input arguments and passes them to the implementation version
 * of the function, appearing above.
 */
static void mlfRecarga_2_3_StorageTexture_Callback(mxArray * hObject,
                                                   mxArray * eventdata,
                                                   mxArray * handles) {
    mlfEnterNewContext(0, 3, hObject, eventdata, handles);
    Mrecarga_2_3_StorageTexture_Callback(hObject, eventdata, handles);
    mlfRestorePreviousContext(0, 3, hObject, eventdata, handles);
}

/*
 * The function "mlxRecarga_2_3_StorageTexture_Callback" contains the feval
 * interface for the "recarga_2_3/StorageTexture_Callback" M-function from file
 * "u:\final_recarga6\recarga\recarga_2_3.m" (lines 1449-1459). The feval
 * function calls the implementation version of
 * recarga_2_3/StorageTexture_Callback through this function. This function
 * processes any input arguments and passes them to the implementation version
 * of the function, appearing above.
 */
static void mlxRecarga_2_3_StorageTexture_Callback(int nlhs,
                                                   mxArray * plhs[],
                                                   int nrhs,
                                                   mxArray * prhs[]) {
    mxArray * mprhs[3];
    int i;
    if (nlhs > 0) {
        mlfError(
          mxCreateString(
            "Run-time Error: File: recarga_2_3/StorageTexture_Callback Line: 14"
            "49 Column: 1 The function \"recarga_2_3/StorageTexture_Callback\" "
            "was called with more than the declared number of outputs (0)."),
          NULL);
    }
    if (nrhs > 3) {
        mlfError(
          mxCreateString(
            "Run-time Error: File: recarga_2_3/StorageTexture_Callback Line: 1"
            "449 Column: 1 The function \"recarga_2_3/StorageTexture_Callback"
            "\" was called with more than the declared number of inputs (3)."),
          NULL);
    }
    for (i = 0; i < 3 && i < nrhs; ++i) {
        mprhs[i] = prhs[i];
    }
    for (; i < 3; ++i) {
        mprhs[i] = NULL;
    }
    mlfEnterNewContext(0, 3, mprhs[0], mprhs[1], mprhs[2]);
    Mrecarga_2_3_StorageTexture_Callback(mprhs[0], mprhs[1], mprhs[2]);
    mlfRestorePreviousContext(0, 3, mprhs[0], mprhs[1], mprhs[2]);
}

/*
 * The function "mlfRecarga_2_3_NativeTexture_CreateFcn" contains the normal
 * interface for the "recarga_2_3/NativeTexture_CreateFcn" M-function from file
 * "u:\final_recarga6\recarga\recarga_2_3.m" (lines 1459-1474). This function
 * processes any input arguments and passes them to the implementation version
 * of the function, appearing above.
 */
static void mlfRecarga_2_3_NativeTexture_CreateFcn(mxArray * hObject,
                                                   mxArray * eventdata,
                                                   mxArray * handles) {
    mlfEnterNewContext(0, 3, hObject, eventdata, handles);
    Mrecarga_2_3_NativeTexture_CreateFcn(hObject, eventdata, handles);
    mlfRestorePreviousContext(0, 3, hObject, eventdata, handles);
}

/*
 * The function "mlxRecarga_2_3_NativeTexture_CreateFcn" contains the feval
 * interface for the "recarga_2_3/NativeTexture_CreateFcn" M-function from file
 * "u:\final_recarga6\recarga\recarga_2_3.m" (lines 1459-1474). The feval
 * function calls the implementation version of
 * recarga_2_3/NativeTexture_CreateFcn through this function. This function
 * processes any input arguments and passes them to the implementation version
 * of the function, appearing above.
 */
static void mlxRecarga_2_3_NativeTexture_CreateFcn(int nlhs,
                                                   mxArray * plhs[],
                                                   int nrhs,
                                                   mxArray * prhs[]) {
    mxArray * mprhs[3];
    int i;
    if (nlhs > 0) {
        mlfError(
          mxCreateString(
            "Run-time Error: File: recarga_2_3/NativeTexture_CreateFcn Line: 14"
            "59 Column: 1 The function \"recarga_2_3/NativeTexture_CreateFcn\" "
            "was called with more than the declared number of outputs (0)."),
          NULL);
    }
    if (nrhs > 3) {
        mlfError(
          mxCreateString(
            "Run-time Error: File: recarga_2_3/NativeTexture_CreateFcn Line: 1"
            "459 Column: 1 The function \"recarga_2_3/NativeTexture_CreateFcn"
            "\" was called with more than the declared number of inputs (3)."),
          NULL);
    }
    for (i = 0; i < 3 && i < nrhs; ++i) {
        mprhs[i] = prhs[i];
    }
    for (; i < 3; ++i) {
        mprhs[i] = NULL;
    }
    mlfEnterNewContext(0, 3, mprhs[0], mprhs[1], mprhs[2]);
    Mrecarga_2_3_NativeTexture_CreateFcn(mprhs[0], mprhs[1], mprhs[2]);
    mlfRestorePreviousContext(0, 3, mprhs[0], mprhs[1], mprhs[2]);
}

/*
 * The function "mlfRecarga_2_3_NativeTexture_Callback" contains the normal
 * interface for the "recarga_2_3/NativeTexture_Callback" M-function from file
 * "u:\final_recarga6\recarga\recarga_2_3.m" (lines 1474-1493). This function
 * processes any input arguments and passes them to the implementation version
 * of the function, appearing above.
 */
static void mlfRecarga_2_3_NativeTexture_Callback(mxArray * hObject,
                                                  mxArray * eventdata,
                                                  mxArray * handles) {
    mlfEnterNewContext(0, 3, hObject, eventdata, handles);
    Mrecarga_2_3_NativeTexture_Callback(hObject, eventdata, handles);
    mlfRestorePreviousContext(0, 3, hObject, eventdata, handles);
}

/*
 * The function "mlxRecarga_2_3_NativeTexture_Callback" contains the feval
 * interface for the "recarga_2_3/NativeTexture_Callback" M-function from file
 * "u:\final_recarga6\recarga\recarga_2_3.m" (lines 1474-1493). The feval
 * function calls the implementation version of
 * recarga_2_3/NativeTexture_Callback through this function. This function
 * processes any input arguments and passes them to the implementation version
 * of the function, appearing above.
 */
static void mlxRecarga_2_3_NativeTexture_Callback(int nlhs,
                                                  mxArray * plhs[],
                                                  int nrhs,
                                                  mxArray * prhs[]) {
    mxArray * mprhs[3];
    int i;
    if (nlhs > 0) {
        mlfError(
          mxCreateString(
            "Run-time Error: File: recarga_2_3/NativeTexture_Callback Line: 14"
            "74 Column: 1 The function \"recarga_2_3/NativeTexture_Callback\" "
            "was called with more than the declared number of outputs (0)."),
          NULL);
    }
    if (nrhs > 3) {
        mlfError(
          mxCreateString(
            "Run-time Error: File: recarga_2_3/NativeTexture_Callback Line: 14"
            "74 Column: 1 The function \"recarga_2_3/NativeTexture_Callback\" "
            "was called with more than the declared number of inputs (3)."),
          NULL);
    }
    for (i = 0; i < 3 && i < nrhs; ++i) {
        mprhs[i] = prhs[i];
    }
    for (; i < 3; ++i) {
        mprhs[i] = NULL;
    }
    mlfEnterNewContext(0, 3, mprhs[0], mprhs[1], mprhs[2]);
    Mrecarga_2_3_NativeTexture_Callback(mprhs[0], mprhs[1], mprhs[2]);
    mlfRestorePreviousContext(0, 3, mprhs[0], mprhs[1], mprhs[2]);
}

/*
 * The function "mlfRecarga_2_3_Kstore_CreateFcn" contains the normal interface
 * for the "recarga_2_3/Kstore_CreateFcn" M-function from file
 * "u:\final_recarga6\recarga\recarga_2_3.m" (lines 1493-1508). This function
 * processes any input arguments and passes them to the implementation version
 * of the function, appearing above.
 */
static void mlfRecarga_2_3_Kstore_CreateFcn(mxArray * hObject,
                                            mxArray * eventdata,
                                            mxArray * handles) {
    mlfEnterNewContext(0, 3, hObject, eventdata, handles);
    Mrecarga_2_3_Kstore_CreateFcn(hObject, eventdata, handles);
    mlfRestorePreviousContext(0, 3, hObject, eventdata, handles);
}

/*
 * The function "mlxRecarga_2_3_Kstore_CreateFcn" contains the feval interface
 * for the "recarga_2_3/Kstore_CreateFcn" M-function from file
 * "u:\final_recarga6\recarga\recarga_2_3.m" (lines 1493-1508). The feval
 * function calls the implementation version of recarga_2_3/Kstore_CreateFcn
 * through this function. This function processes any input arguments and
 * passes them to the implementation version of the function, appearing above.
 */
static void mlxRecarga_2_3_Kstore_CreateFcn(int nlhs,
                                            mxArray * plhs[],
                                            int nrhs,
                                            mxArray * prhs[]) {
    mxArray * mprhs[3];
    int i;
    if (nlhs > 0) {
        mlfError(
          mxCreateString(
            "Run-time Error: File: recarga_2_3/Kstore_CreateFcn Line: 1493"
            " Column: 1 The function \"recarga_2_3/Kstore_CreateFcn\" was "
            "called with more than the declared number of outputs (0)."),
          NULL);
    }
    if (nrhs > 3) {
        mlfError(
          mxCreateString(
            "Run-time Error: File: recarga_2_3/Kstore_CreateFcn Line: 149"
            "3 Column: 1 The function \"recarga_2_3/Kstore_CreateFcn\" wa"
            "s called with more than the declared number of inputs (3)."),
          NULL);
    }
    for (i = 0; i < 3 && i < nrhs; ++i) {
        mprhs[i] = prhs[i];
    }
    for (; i < 3; ++i) {
        mprhs[i] = NULL;
    }
    mlfEnterNewContext(0, 3, mprhs[0], mprhs[1], mprhs[2]);
    Mrecarga_2_3_Kstore_CreateFcn(mprhs[0], mprhs[1], mprhs[2]);
    mlfRestorePreviousContext(0, 3, mprhs[0], mprhs[1], mprhs[2]);
}

/*
 * The function "mlfRecarga_2_3_Kstore_Callback" contains the normal interface
 * for the "recarga_2_3/Kstore_Callback" M-function from file
 * "u:\final_recarga6\recarga\recarga_2_3.m" (lines 1508-1518). This function
 * processes any input arguments and passes them to the implementation version
 * of the function, appearing above.
 */
static void mlfRecarga_2_3_Kstore_Callback(mxArray * hObject,
                                           mxArray * eventdata,
                                           mxArray * handles) {
    mlfEnterNewContext(0, 3, hObject, eventdata, handles);
    Mrecarga_2_3_Kstore_Callback(hObject, eventdata, handles);
    mlfRestorePreviousContext(0, 3, hObject, eventdata, handles);
}

/*
 * The function "mlxRecarga_2_3_Kstore_Callback" contains the feval interface
 * for the "recarga_2_3/Kstore_Callback" M-function from file
 * "u:\final_recarga6\recarga\recarga_2_3.m" (lines 1508-1518). The feval
 * function calls the implementation version of recarga_2_3/Kstore_Callback
 * through this function. This function processes any input arguments and
 * passes them to the implementation version of the function, appearing above.
 */
static void mlxRecarga_2_3_Kstore_Callback(int nlhs,
                                           mxArray * plhs[],
                                           int nrhs,
                                           mxArray * prhs[]) {
    mxArray * mprhs[3];
    int i;
    if (nlhs > 0) {
        mlfError(
          mxCreateString(
            "Run-time Error: File: recarga_2_3/Kstore_Callback Line: 1508"
            " Column: 1 The function \"recarga_2_3/Kstore_Callback\" was "
            "called with more than the declared number of outputs (0)."),
          NULL);
    }
    if (nrhs > 3) {
        mlfError(
          mxCreateString(
            "Run-time Error: File: recarga_2_3/Kstore_Callback Line: 1508"
            " Column: 1 The function \"recarga_2_3/Kstore_Callback\" was "
            "called with more than the declared number of inputs (3)."),
          NULL);
    }
    for (i = 0; i < 3 && i < nrhs; ++i) {
        mprhs[i] = prhs[i];
    }
    for (; i < 3; ++i) {
        mprhs[i] = NULL;
    }
    mlfEnterNewContext(0, 3, mprhs[0], mprhs[1], mprhs[2]);
    Mrecarga_2_3_Kstore_Callback(mprhs[0], mprhs[1], mprhs[2]);
    mlfRestorePreviousContext(0, 3, mprhs[0], mprhs[1], mprhs[2]);
}

/*
 * The function "mlfRecarga_2_3_Kroot_CreateFcn" contains the normal interface
 * for the "recarga_2_3/Kroot_CreateFcn" M-function from file
 * "u:\final_recarga6\recarga\recarga_2_3.m" (lines 1518-1533). This function
 * processes any input arguments and passes them to the implementation version
 * of the function, appearing above.
 */
static void mlfRecarga_2_3_Kroot_CreateFcn(mxArray * hObject,
                                           mxArray * eventdata,
                                           mxArray * handles) {
    mlfEnterNewContext(0, 3, hObject, eventdata, handles);
    Mrecarga_2_3_Kroot_CreateFcn(hObject, eventdata, handles);
    mlfRestorePreviousContext(0, 3, hObject, eventdata, handles);
}

/*
 * The function "mlxRecarga_2_3_Kroot_CreateFcn" contains the feval interface
 * for the "recarga_2_3/Kroot_CreateFcn" M-function from file
 * "u:\final_recarga6\recarga\recarga_2_3.m" (lines 1518-1533). The feval
 * function calls the implementation version of recarga_2_3/Kroot_CreateFcn
 * through this function. This function processes any input arguments and
 * passes them to the implementation version of the function, appearing above.
 */
static void mlxRecarga_2_3_Kroot_CreateFcn(int nlhs,
                                           mxArray * plhs[],
                                           int nrhs,
                                           mxArray * prhs[]) {
    mxArray * mprhs[3];
    int i;
    if (nlhs > 0) {
        mlfError(
          mxCreateString(
            "Run-time Error: File: recarga_2_3/Kroot_CreateFcn Line: 1518"
            " Column: 1 The function \"recarga_2_3/Kroot_CreateFcn\" was "
            "called with more than the declared number of outputs (0)."),
          NULL);
    }
    if (nrhs > 3) {
        mlfError(
          mxCreateString(
            "Run-time Error: File: recarga_2_3/Kroot_CreateFcn Line: 1518"
            " Column: 1 The function \"recarga_2_3/Kroot_CreateFcn\" was "
            "called with more than the declared number of inputs (3)."),
          NULL);
    }
    for (i = 0; i < 3 && i < nrhs; ++i) {
        mprhs[i] = prhs[i];
    }
    for (; i < 3; ++i) {
        mprhs[i] = NULL;
    }
    mlfEnterNewContext(0, 3, mprhs[0], mprhs[1], mprhs[2]);
    Mrecarga_2_3_Kroot_CreateFcn(mprhs[0], mprhs[1], mprhs[2]);
    mlfRestorePreviousContext(0, 3, mprhs[0], mprhs[1], mprhs[2]);
}

/*
 * The function "mlfRecarga_2_3_Kroot_Callback" contains the normal interface
 * for the "recarga_2_3/Kroot_Callback" M-function from file
 * "u:\final_recarga6\recarga\recarga_2_3.m" (lines 1533-1543). This function
 * processes any input arguments and passes them to the implementation version
 * of the function, appearing above.
 */
static void mlfRecarga_2_3_Kroot_Callback(mxArray * hObject,
                                          mxArray * eventdata,
                                          mxArray * handles) {
    mlfEnterNewContext(0, 3, hObject, eventdata, handles);
    Mrecarga_2_3_Kroot_Callback(hObject, eventdata, handles);
    mlfRestorePreviousContext(0, 3, hObject, eventdata, handles);
}

/*
 * The function "mlxRecarga_2_3_Kroot_Callback" contains the feval interface
 * for the "recarga_2_3/Kroot_Callback" M-function from file
 * "u:\final_recarga6\recarga\recarga_2_3.m" (lines 1533-1543). The feval
 * function calls the implementation version of recarga_2_3/Kroot_Callback
 * through this function. This function processes any input arguments and
 * passes them to the implementation version of the function, appearing above.
 */
static void mlxRecarga_2_3_Kroot_Callback(int nlhs,
                                          mxArray * plhs[],
                                          int nrhs,
                                          mxArray * prhs[]) {
    mxArray * mprhs[3];
    int i;
    if (nlhs > 0) {
        mlfError(
          mxCreateString(
            "Run-time Error: File: recarga_2_3/Kroot_Callback Line: 1533"
            " Column: 1 The function \"recarga_2_3/Kroot_Callback\" was "
            "called with more than the declared number of outputs (0)."),
          NULL);
    }
    if (nrhs > 3) {
        mlfError(
          mxCreateString(
            "Run-time Error: File: recarga_2_3/Kroot_Callback Line: 1533"
            " Column: 1 The function \"recarga_2_3/Kroot_Callback\" was "
            "called with more than the declared number of inputs (3)."),
          NULL);
    }
    for (i = 0; i < 3 && i < nrhs; ++i) {
        mprhs[i] = prhs[i];
    }
    for (; i < 3; ++i) {
        mprhs[i] = NULL;
    }
    mlfEnterNewContext(0, 3, mprhs[0], mprhs[1], mprhs[2]);
    Mrecarga_2_3_Kroot_Callback(mprhs[0], mprhs[1], mprhs[2]);
    mlfRestorePreviousContext(0, 3, mprhs[0], mprhs[1], mprhs[2]);
}

/*
 * The function "mlfRecarga_2_3_pushbutton3_Callback" contains the normal
 * interface for the "recarga_2_3/pushbutton3_Callback" M-function from file
 * "u:\final_recarga6\recarga\recarga_2_3.m" (lines 1543-1550). This function
 * processes any input arguments and passes them to the implementation version
 * of the function, appearing above.
 */
static void mlfRecarga_2_3_pushbutton3_Callback(mxArray * hObject,
                                                mxArray * eventdata,
                                                mxArray * handles) {
    mlfEnterNewContext(0, 3, hObject, eventdata, handles);
    Mrecarga_2_3_pushbutton3_Callback(hObject, eventdata, handles);
    mlfRestorePreviousContext(0, 3, hObject, eventdata, handles);
}

/*
 * The function "mlxRecarga_2_3_pushbutton3_Callback" contains the feval
 * interface for the "recarga_2_3/pushbutton3_Callback" M-function from file
 * "u:\final_recarga6\recarga\recarga_2_3.m" (lines 1543-1550). The feval
 * function calls the implementation version of
 * recarga_2_3/pushbutton3_Callback through this function. This function
 * processes any input arguments and passes them to the implementation version
 * of the function, appearing above.
 */
static void mlxRecarga_2_3_pushbutton3_Callback(int nlhs,
                                                mxArray * plhs[],
                                                int nrhs,
                                                mxArray * prhs[]) {
    mxArray * mprhs[3];
    int i;
    if (nlhs > 0) {
        mlfError(
          mxCreateString(
            "Run-time Error: File: recarga_2_3/pushbutton3_Callback Line: 15"
            "43 Column: 1 The function \"recarga_2_3/pushbutton3_Callback\" "
            "was called with more than the declared number of outputs (0)."),
          NULL);
    }
    if (nrhs > 3) {
        mlfError(
          mxCreateString(
            "Run-time Error: File: recarga_2_3/pushbutton3_Callback Line: 15"
            "43 Column: 1 The function \"recarga_2_3/pushbutton3_Callback\" "
            "was called with more than the declared number of inputs (3)."),
          NULL);
    }
    for (i = 0; i < 3 && i < nrhs; ++i) {
        mprhs[i] = prhs[i];
    }
    for (; i < 3; ++i) {
        mprhs[i] = NULL;
    }
    mlfEnterNewContext(0, 3, mprhs[0], mprhs[1], mprhs[2]);
    Mrecarga_2_3_pushbutton3_Callback(mprhs[0], mprhs[1], mprhs[2]);
    mlfRestorePreviousContext(0, 3, mprhs[0], mprhs[1], mprhs[2]);
}

/*
 * The function "mlfRecarga_2_3_SMVol_CreateFcn" contains the normal interface
 * for the "recarga_2_3/SMVol_CreateFcn" M-function from file
 * "u:\final_recarga6\recarga\recarga_2_3.m" (lines 1550-1565). This function
 * processes any input arguments and passes them to the implementation version
 * of the function, appearing above.
 */
static void mlfRecarga_2_3_SMVol_CreateFcn(mxArray * hObject,
                                           mxArray * eventdata,
                                           mxArray * handles) {
    mlfEnterNewContext(0, 3, hObject, eventdata, handles);
    Mrecarga_2_3_SMVol_CreateFcn(hObject, eventdata, handles);
    mlfRestorePreviousContext(0, 3, hObject, eventdata, handles);
}

/*
 * The function "mlxRecarga_2_3_SMVol_CreateFcn" contains the feval interface
 * for the "recarga_2_3/SMVol_CreateFcn" M-function from file
 * "u:\final_recarga6\recarga\recarga_2_3.m" (lines 1550-1565). The feval
 * function calls the implementation version of recarga_2_3/SMVol_CreateFcn
 * through this function. This function processes any input arguments and
 * passes them to the implementation version of the function, appearing above.
 */
static void mlxRecarga_2_3_SMVol_CreateFcn(int nlhs,
                                           mxArray * plhs[],
                                           int nrhs,
                                           mxArray * prhs[]) {
    mxArray * mprhs[3];
    int i;
    if (nlhs > 0) {
        mlfError(
          mxCreateString(
            "Run-time Error: File: recarga_2_3/SMVol_CreateFcn Line: 1550"
            " Column: 1 The function \"recarga_2_3/SMVol_CreateFcn\" was "
            "called with more than the declared number of outputs (0)."),
          NULL);
    }
    if (nrhs > 3) {
        mlfError(
          mxCreateString(
            "Run-time Error: File: recarga_2_3/SMVol_CreateFcn Line: 1550"
            " Column: 1 The function \"recarga_2_3/SMVol_CreateFcn\" was "
            "called with more than the declared number of inputs (3)."),
          NULL);
    }
    for (i = 0; i < 3 && i < nrhs; ++i) {
        mprhs[i] = prhs[i];
    }
    for (; i < 3; ++i) {
        mprhs[i] = NULL;
    }
    mlfEnterNewContext(0, 3, mprhs[0], mprhs[1], mprhs[2]);
    Mrecarga_2_3_SMVol_CreateFcn(mprhs[0], mprhs[1], mprhs[2]);
    mlfRestorePreviousContext(0, 3, mprhs[0], mprhs[1], mprhs[2]);
}

/*
 * The function "mlfRecarga_2_3_SMVol_Callback" contains the normal interface
 * for the "recarga_2_3/SMVol_Callback" M-function from file
 * "u:\final_recarga6\recarga\recarga_2_3.m" (lines 1565-1575). This function
 * processes any input arguments and passes them to the implementation version
 * of the function, appearing above.
 */
static void mlfRecarga_2_3_SMVol_Callback(mxArray * hObject,
                                          mxArray * eventdata,
                                          mxArray * handles) {
    mlfEnterNewContext(0, 3, hObject, eventdata, handles);
    Mrecarga_2_3_SMVol_Callback(hObject, eventdata, handles);
    mlfRestorePreviousContext(0, 3, hObject, eventdata, handles);
}

/*
 * The function "mlxRecarga_2_3_SMVol_Callback" contains the feval interface
 * for the "recarga_2_3/SMVol_Callback" M-function from file
 * "u:\final_recarga6\recarga\recarga_2_3.m" (lines 1565-1575). The feval
 * function calls the implementation version of recarga_2_3/SMVol_Callback
 * through this function. This function processes any input arguments and
 * passes them to the implementation version of the function, appearing above.
 */
static void mlxRecarga_2_3_SMVol_Callback(int nlhs,
                                          mxArray * plhs[],
                                          int nrhs,
                                          mxArray * prhs[]) {
    mxArray * mprhs[3];
    int i;
    if (nlhs > 0) {
        mlfError(
          mxCreateString(
            "Run-time Error: File: recarga_2_3/SMVol_Callback Line: 1565"
            " Column: 1 The function \"recarga_2_3/SMVol_Callback\" was "
            "called with more than the declared number of outputs (0)."),
          NULL);
    }
    if (nrhs > 3) {
        mlfError(
          mxCreateString(
            "Run-time Error: File: recarga_2_3/SMVol_Callback Line: 1565"
            " Column: 1 The function \"recarga_2_3/SMVol_Callback\" was "
            "called with more than the declared number of inputs (3)."),
          NULL);
    }
    for (i = 0; i < 3 && i < nrhs; ++i) {
        mprhs[i] = prhs[i];
    }
    for (; i < 3; ++i) {
        mprhs[i] = NULL;
    }
    mlfEnterNewContext(0, 3, mprhs[0], mprhs[1], mprhs[2]);
    Mrecarga_2_3_SMVol_Callback(mprhs[0], mprhs[1], mprhs[2]);
    mlfRestorePreviousContext(0, 3, mprhs[0], mprhs[1], mprhs[2]);
}

/*
 * The function "mlfRecarga_2_3_SMpercent_CreateFcn" contains the normal
 * interface for the "recarga_2_3/SMpercent_CreateFcn" M-function from file
 * "u:\final_recarga6\recarga\recarga_2_3.m" (lines 1575-1590). This function
 * processes any input arguments and passes them to the implementation version
 * of the function, appearing above.
 */
static void mlfRecarga_2_3_SMpercent_CreateFcn(mxArray * hObject,
                                               mxArray * eventdata,
                                               mxArray * handles) {
    mlfEnterNewContext(0, 3, hObject, eventdata, handles);
    Mrecarga_2_3_SMpercent_CreateFcn(hObject, eventdata, handles);
    mlfRestorePreviousContext(0, 3, hObject, eventdata, handles);
}

/*
 * The function "mlxRecarga_2_3_SMpercent_CreateFcn" contains the feval
 * interface for the "recarga_2_3/SMpercent_CreateFcn" M-function from file
 * "u:\final_recarga6\recarga\recarga_2_3.m" (lines 1575-1590). The feval
 * function calls the implementation version of recarga_2_3/SMpercent_CreateFcn
 * through this function. This function processes any input arguments and
 * passes them to the implementation version of the function, appearing above.
 */
static void mlxRecarga_2_3_SMpercent_CreateFcn(int nlhs,
                                               mxArray * plhs[],
                                               int nrhs,
                                               mxArray * prhs[]) {
    mxArray * mprhs[3];
    int i;
    if (nlhs > 0) {
        mlfError(
          mxCreateString(
            "Run-time Error: File: recarga_2_3/SMpercent_CreateFcn Line: 157"
            "5 Column: 1 The function \"recarga_2_3/SMpercent_CreateFcn\" wa"
            "s called with more than the declared number of outputs (0)."),
          NULL);
    }
    if (nrhs > 3) {
        mlfError(
          mxCreateString(
            "Run-time Error: File: recarga_2_3/SMpercent_CreateFcn Line: 15"
            "75 Column: 1 The function \"recarga_2_3/SMpercent_CreateFcn\" "
            "was called with more than the declared number of inputs (3)."),
          NULL);
    }
    for (i = 0; i < 3 && i < nrhs; ++i) {
        mprhs[i] = prhs[i];
    }
    for (; i < 3; ++i) {
        mprhs[i] = NULL;
    }
    mlfEnterNewContext(0, 3, mprhs[0], mprhs[1], mprhs[2]);
    Mrecarga_2_3_SMpercent_CreateFcn(mprhs[0], mprhs[1], mprhs[2]);
    mlfRestorePreviousContext(0, 3, mprhs[0], mprhs[1], mprhs[2]);
}

/*
 * The function "mlfRecarga_2_3_SMpercent_Callback" contains the normal
 * interface for the "recarga_2_3/SMpercent_Callback" M-function from file
 * "u:\final_recarga6\recarga\recarga_2_3.m" (lines 1590-1600). This function
 * processes any input arguments and passes them to the implementation version
 * of the function, appearing above.
 */
static void mlfRecarga_2_3_SMpercent_Callback(mxArray * hObject,
                                              mxArray * eventdata,
                                              mxArray * handles) {
    mlfEnterNewContext(0, 3, hObject, eventdata, handles);
    Mrecarga_2_3_SMpercent_Callback(hObject, eventdata, handles);
    mlfRestorePreviousContext(0, 3, hObject, eventdata, handles);
}

/*
 * The function "mlxRecarga_2_3_SMpercent_Callback" contains the feval
 * interface for the "recarga_2_3/SMpercent_Callback" M-function from file
 * "u:\final_recarga6\recarga\recarga_2_3.m" (lines 1590-1600). The feval
 * function calls the implementation version of recarga_2_3/SMpercent_Callback
 * through this function. This function processes any input arguments and
 * passes them to the implementation version of the function, appearing above.
 */
static void mlxRecarga_2_3_SMpercent_Callback(int nlhs,
                                              mxArray * plhs[],
                                              int nrhs,
                                              mxArray * prhs[]) {
    mxArray * mprhs[3];
    int i;
    if (nlhs > 0) {
        mlfError(
          mxCreateString(
            "Run-time Error: File: recarga_2_3/SMpercent_Callback Line: 159"
            "0 Column: 1 The function \"recarga_2_3/SMpercent_Callback\" wa"
            "s called with more than the declared number of outputs (0)."),
          NULL);
    }
    if (nrhs > 3) {
        mlfError(
          mxCreateString(
            "Run-time Error: File: recarga_2_3/SMpercent_Callback Line: 159"
            "0 Column: 1 The function \"recarga_2_3/SMpercent_Callback\" wa"
            "s called with more than the declared number of inputs (3)."),
          NULL);
    }
    for (i = 0; i < 3 && i < nrhs; ++i) {
        mprhs[i] = prhs[i];
    }
    for (; i < 3; ++i) {
        mprhs[i] = NULL;
    }
    mlfEnterNewContext(0, 3, mprhs[0], mprhs[1], mprhs[2]);
    Mrecarga_2_3_SMpercent_Callback(mprhs[0], mprhs[1], mprhs[2]);
    mlfRestorePreviousContext(0, 3, mprhs[0], mprhs[1], mprhs[2]);
}

/*
 * The function "mlfRecarga_2_3_SMdepth_CreateFcn" contains the normal
 * interface for the "recarga_2_3/SMdepth_CreateFcn" M-function from file
 * "u:\final_recarga6\recarga\recarga_2_3.m" (lines 1600-1615). This function
 * processes any input arguments and passes them to the implementation version
 * of the function, appearing above.
 */
static void mlfRecarga_2_3_SMdepth_CreateFcn(mxArray * hObject,
                                             mxArray * eventdata,
                                             mxArray * handles) {
    mlfEnterNewContext(0, 3, hObject, eventdata, handles);
    Mrecarga_2_3_SMdepth_CreateFcn(hObject, eventdata, handles);
    mlfRestorePreviousContext(0, 3, hObject, eventdata, handles);
}

/*
 * The function "mlxRecarga_2_3_SMdepth_CreateFcn" contains the feval interface
 * for the "recarga_2_3/SMdepth_CreateFcn" M-function from file
 * "u:\final_recarga6\recarga\recarga_2_3.m" (lines 1600-1615). The feval
 * function calls the implementation version of recarga_2_3/SMdepth_CreateFcn
 * through this function. This function processes any input arguments and
 * passes them to the implementation version of the function, appearing above.
 */
static void mlxRecarga_2_3_SMdepth_CreateFcn(int nlhs,
                                             mxArray * plhs[],
                                             int nrhs,
                                             mxArray * prhs[]) {
    mxArray * mprhs[3];
    int i;
    if (nlhs > 0) {
        mlfError(
          mxCreateString(
            "Run-time Error: File: recarga_2_3/SMdepth_CreateFcn Line: 160"
            "0 Column: 1 The function \"recarga_2_3/SMdepth_CreateFcn\" wa"
            "s called with more than the declared number of outputs (0)."),
          NULL);
    }
    if (nrhs > 3) {
        mlfError(
          mxCreateString(
            "Run-time Error: File: recarga_2_3/SMdepth_CreateFcn Line: 160"
            "0 Column: 1 The function \"recarga_2_3/SMdepth_CreateFcn\" wa"
            "s called with more than the declared number of inputs (3)."),
          NULL);
    }
    for (i = 0; i < 3 && i < nrhs; ++i) {
        mprhs[i] = prhs[i];
    }
    for (; i < 3; ++i) {
        mprhs[i] = NULL;
    }
    mlfEnterNewContext(0, 3, mprhs[0], mprhs[1], mprhs[2]);
    Mrecarga_2_3_SMdepth_CreateFcn(mprhs[0], mprhs[1], mprhs[2]);
    mlfRestorePreviousContext(0, 3, mprhs[0], mprhs[1], mprhs[2]);
}

/*
 * The function "mlfRecarga_2_3_SMdepth_Callback" contains the normal interface
 * for the "recarga_2_3/SMdepth_Callback" M-function from file
 * "u:\final_recarga6\recarga\recarga_2_3.m" (lines 1615-1625). This function
 * processes any input arguments and passes them to the implementation version
 * of the function, appearing above.
 */
static void mlfRecarga_2_3_SMdepth_Callback(mxArray * hObject,
                                            mxArray * eventdata,
                                            mxArray * handles) {
    mlfEnterNewContext(0, 3, hObject, eventdata, handles);
    Mrecarga_2_3_SMdepth_Callback(hObject, eventdata, handles);
    mlfRestorePreviousContext(0, 3, hObject, eventdata, handles);
}

/*
 * The function "mlxRecarga_2_3_SMdepth_Callback" contains the feval interface
 * for the "recarga_2_3/SMdepth_Callback" M-function from file
 * "u:\final_recarga6\recarga\recarga_2_3.m" (lines 1615-1625). The feval
 * function calls the implementation version of recarga_2_3/SMdepth_Callback
 * through this function. This function processes any input arguments and
 * passes them to the implementation version of the function, appearing above.
 */
static void mlxRecarga_2_3_SMdepth_Callback(int nlhs,
                                            mxArray * plhs[],
                                            int nrhs,
                                            mxArray * prhs[]) {
    mxArray * mprhs[3];
    int i;
    if (nlhs > 0) {
        mlfError(
          mxCreateString(
            "Run-time Error: File: recarga_2_3/SMdepth_Callback Line: 1615"
            " Column: 1 The function \"recarga_2_3/SMdepth_Callback\" was "
            "called with more than the declared number of outputs (0)."),
          NULL);
    }
    if (nrhs > 3) {
        mlfError(
          mxCreateString(
            "Run-time Error: File: recarga_2_3/SMdepth_Callback Line: 161"
            "5 Column: 1 The function \"recarga_2_3/SMdepth_Callback\" wa"
            "s called with more than the declared number of inputs (3)."),
          NULL);
    }
    for (i = 0; i < 3 && i < nrhs; ++i) {
        mprhs[i] = prhs[i];
    }
    for (; i < 3; ++i) {
        mprhs[i] = NULL;
    }
    mlfEnterNewContext(0, 3, mprhs[0], mprhs[1], mprhs[2]);
    Mrecarga_2_3_SMdepth_Callback(mprhs[0], mprhs[1], mprhs[2]);
    mlfRestorePreviousContext(0, 3, mprhs[0], mprhs[1], mprhs[2]);
}

/*
 * The function "mlfRecarga_2_3_Untitled_1_Callback" contains the normal
 * interface for the "recarga_2_3/Untitled_1_Callback" M-function from file
 * "u:\final_recarga6\recarga\recarga_2_3.m" (lines 1625-1632). This function
 * processes any input arguments and passes them to the implementation version
 * of the function, appearing above.
 */
static void mlfRecarga_2_3_Untitled_1_Callback(mxArray * hObject,
                                               mxArray * eventdata,
                                               mxArray * handles) {
    mlfEnterNewContext(0, 3, hObject, eventdata, handles);
    Mrecarga_2_3_Untitled_1_Callback(hObject, eventdata, handles);
    mlfRestorePreviousContext(0, 3, hObject, eventdata, handles);
}

/*
 * The function "mlxRecarga_2_3_Untitled_1_Callback" contains the feval
 * interface for the "recarga_2_3/Untitled_1_Callback" M-function from file
 * "u:\final_recarga6\recarga\recarga_2_3.m" (lines 1625-1632). The feval
 * function calls the implementation version of recarga_2_3/Untitled_1_Callback
 * through this function. This function processes any input arguments and
 * passes them to the implementation version of the function, appearing above.
 */
static void mlxRecarga_2_3_Untitled_1_Callback(int nlhs,
                                               mxArray * plhs[],
                                               int nrhs,
                                               mxArray * prhs[]) {
    mxArray * mprhs[3];
    int i;
    if (nlhs > 0) {
        mlfError(
          mxCreateString(
            "Run-time Error: File: recarga_2_3/Untitled_1_Callback Line: 162"
            "5 Column: 1 The function \"recarga_2_3/Untitled_1_Callback\" wa"
            "s called with more than the declared number of outputs (0)."),
          NULL);
    }
    if (nrhs > 3) {
        mlfError(
          mxCreateString(
            "Run-time Error: File: recarga_2_3/Untitled_1_Callback Line: 16"
            "25 Column: 1 The function \"recarga_2_3/Untitled_1_Callback\" "
            "was called with more than the declared number of inputs (3)."),
          NULL);
    }
    for (i = 0; i < 3 && i < nrhs; ++i) {
        mprhs[i] = prhs[i];
    }
    for (; i < 3; ++i) {
        mprhs[i] = NULL;
    }
    mlfEnterNewContext(0, 3, mprhs[0], mprhs[1], mprhs[2]);
    Mrecarga_2_3_Untitled_1_Callback(mprhs[0], mprhs[1], mprhs[2]);
    mlfRestorePreviousContext(0, 3, mprhs[0], mprhs[1], mprhs[2]);
}

/*
 * The function "mlfRecarga_2_3_Untitled_2_Callback" contains the normal
 * interface for the "recarga_2_3/Untitled_2_Callback" M-function from file
 * "u:\final_recarga6\recarga\recarga_2_3.m" (lines 1632-1639). This function
 * processes any input arguments and passes them to the implementation version
 * of the function, appearing above.
 */
static void mlfRecarga_2_3_Untitled_2_Callback(mxArray * hObject,
                                               mxArray * eventdata,
                                               mxArray * handles) {
    mlfEnterNewContext(0, 3, hObject, eventdata, handles);
    Mrecarga_2_3_Untitled_2_Callback(hObject, eventdata, handles);
    mlfRestorePreviousContext(0, 3, hObject, eventdata, handles);
}

/*
 * The function "mlxRecarga_2_3_Untitled_2_Callback" contains the feval
 * interface for the "recarga_2_3/Untitled_2_Callback" M-function from file
 * "u:\final_recarga6\recarga\recarga_2_3.m" (lines 1632-1639). The feval
 * function calls the implementation version of recarga_2_3/Untitled_2_Callback
 * through this function. This function processes any input arguments and
 * passes them to the implementation version of the function, appearing above.
 */
static void mlxRecarga_2_3_Untitled_2_Callback(int nlhs,
                                               mxArray * plhs[],
                                               int nrhs,
                                               mxArray * prhs[]) {
    mxArray * mprhs[3];
    int i;
    if (nlhs > 0) {
        mlfError(
          mxCreateString(
            "Run-time Error: File: recarga_2_3/Untitled_2_Callback Line: 163"
            "2 Column: 1 The function \"recarga_2_3/Untitled_2_Callback\" wa"
            "s called with more than the declared number of outputs (0)."),
          NULL);
    }
    if (nrhs > 3) {
        mlfError(
          mxCreateString(
            "Run-time Error: File: recarga_2_3/Untitled_2_Callback Line: 16"
            "32 Column: 1 The function \"recarga_2_3/Untitled_2_Callback\" "
            "was called with more than the declared number of inputs (3)."),
          NULL);
    }
    for (i = 0; i < 3 && i < nrhs; ++i) {
        mprhs[i] = prhs[i];
    }
    for (; i < 3; ++i) {
        mprhs[i] = NULL;
    }
    mlfEnterNewContext(0, 3, mprhs[0], mprhs[1], mprhs[2]);
    Mrecarga_2_3_Untitled_2_Callback(mprhs[0], mprhs[1], mprhs[2]);
    mlfRestorePreviousContext(0, 3, mprhs[0], mprhs[1], mprhs[2]);
}

/*
 * The function "mlfRecarga_2_3_Stayper_CreateFcn" contains the normal
 * interface for the "recarga_2_3/Stayper_CreateFcn" M-function from file
 * "u:\final_recarga6\recarga\recarga_2_3.m" (lines 1639-1654). This function
 * processes any input arguments and passes them to the implementation version
 * of the function, appearing above.
 */
static void mlfRecarga_2_3_Stayper_CreateFcn(mxArray * hObject,
                                             mxArray * eventdata,
                                             mxArray * handles) {
    mlfEnterNewContext(0, 3, hObject, eventdata, handles);
    Mrecarga_2_3_Stayper_CreateFcn(hObject, eventdata, handles);
    mlfRestorePreviousContext(0, 3, hObject, eventdata, handles);
}

/*
 * The function "mlxRecarga_2_3_Stayper_CreateFcn" contains the feval interface
 * for the "recarga_2_3/Stayper_CreateFcn" M-function from file
 * "u:\final_recarga6\recarga\recarga_2_3.m" (lines 1639-1654). The feval
 * function calls the implementation version of recarga_2_3/Stayper_CreateFcn
 * through this function. This function processes any input arguments and
 * passes them to the implementation version of the function, appearing above.
 */
static void mlxRecarga_2_3_Stayper_CreateFcn(int nlhs,
                                             mxArray * plhs[],
                                             int nrhs,
                                             mxArray * prhs[]) {
    mxArray * mprhs[3];
    int i;
    if (nlhs > 0) {
        mlfError(
          mxCreateString(
            "Run-time Error: File: recarga_2_3/Stayper_CreateFcn Line: 163"
            "9 Column: 1 The function \"recarga_2_3/Stayper_CreateFcn\" wa"
            "s called with more than the declared number of outputs (0)."),
          NULL);
    }
    if (nrhs > 3) {
        mlfError(
          mxCreateString(
            "Run-time Error: File: recarga_2_3/Stayper_CreateFcn Line: 163"
            "9 Column: 1 The function \"recarga_2_3/Stayper_CreateFcn\" wa"
            "s called with more than the declared number of inputs (3)."),
          NULL);
    }
    for (i = 0; i < 3 && i < nrhs; ++i) {
        mprhs[i] = prhs[i];
    }
    for (; i < 3; ++i) {
        mprhs[i] = NULL;
    }
    mlfEnterNewContext(0, 3, mprhs[0], mprhs[1], mprhs[2]);
    Mrecarga_2_3_Stayper_CreateFcn(mprhs[0], mprhs[1], mprhs[2]);
    mlfRestorePreviousContext(0, 3, mprhs[0], mprhs[1], mprhs[2]);
}

/*
 * The function "mlfRecarga_2_3_Stayper_Callback" contains the normal interface
 * for the "recarga_2_3/Stayper_Callback" M-function from file
 * "u:\final_recarga6\recarga\recarga_2_3.m" (lines 1654-1664). This function
 * processes any input arguments and passes them to the implementation version
 * of the function, appearing above.
 */
static void mlfRecarga_2_3_Stayper_Callback(mxArray * hObject,
                                            mxArray * eventdata,
                                            mxArray * handles) {
    mlfEnterNewContext(0, 3, hObject, eventdata, handles);
    Mrecarga_2_3_Stayper_Callback(hObject, eventdata, handles);
    mlfRestorePreviousContext(0, 3, hObject, eventdata, handles);
}

/*
 * The function "mlxRecarga_2_3_Stayper_Callback" contains the feval interface
 * for the "recarga_2_3/Stayper_Callback" M-function from file
 * "u:\final_recarga6\recarga\recarga_2_3.m" (lines 1654-1664). The feval
 * function calls the implementation version of recarga_2_3/Stayper_Callback
 * through this function. This function processes any input arguments and
 * passes them to the implementation version of the function, appearing above.
 */
static void mlxRecarga_2_3_Stayper_Callback(int nlhs,
                                            mxArray * plhs[],
                                            int nrhs,
                                            mxArray * prhs[]) {
    mxArray * mprhs[3];
    int i;
    if (nlhs > 0) {
        mlfError(
          mxCreateString(
            "Run-time Error: File: recarga_2_3/Stayper_Callback Line: 1654"
            " Column: 1 The function \"recarga_2_3/Stayper_Callback\" was "
            "called with more than the declared number of outputs (0)."),
          NULL);
    }
    if (nrhs > 3) {
        mlfError(
          mxCreateString(
            "Run-time Error: File: recarga_2_3/Stayper_Callback Line: 165"
            "4 Column: 1 The function \"recarga_2_3/Stayper_Callback\" wa"
            "s called with more than the declared number of inputs (3)."),
          NULL);
    }
    for (i = 0; i < 3 && i < nrhs; ++i) {
        mprhs[i] = prhs[i];
    }
    for (; i < 3; ++i) {
        mprhs[i] = NULL;
    }
    mlfEnterNewContext(0, 3, mprhs[0], mprhs[1], mprhs[2]);
    Mrecarga_2_3_Stayper_Callback(mprhs[0], mprhs[1], mprhs[2]);
    mlfRestorePreviousContext(0, 3, mprhs[0], mprhs[1], mprhs[2]);
}

/*
 * The function "mlfRecarga_2_3_StayDpth_CreateFcn" contains the normal
 * interface for the "recarga_2_3/StayDpth_CreateFcn" M-function from file
 * "u:\final_recarga6\recarga\recarga_2_3.m" (lines 1664-1679). This function
 * processes any input arguments and passes them to the implementation version
 * of the function, appearing above.
 */
static void mlfRecarga_2_3_StayDpth_CreateFcn(mxArray * hObject,
                                              mxArray * eventdata,
                                              mxArray * handles) {
    mlfEnterNewContext(0, 3, hObject, eventdata, handles);
    Mrecarga_2_3_StayDpth_CreateFcn(hObject, eventdata, handles);
    mlfRestorePreviousContext(0, 3, hObject, eventdata, handles);
}

/*
 * The function "mlxRecarga_2_3_StayDpth_CreateFcn" contains the feval
 * interface for the "recarga_2_3/StayDpth_CreateFcn" M-function from file
 * "u:\final_recarga6\recarga\recarga_2_3.m" (lines 1664-1679). The feval
 * function calls the implementation version of recarga_2_3/StayDpth_CreateFcn
 * through this function. This function processes any input arguments and
 * passes them to the implementation version of the function, appearing above.
 */
static void mlxRecarga_2_3_StayDpth_CreateFcn(int nlhs,
                                              mxArray * plhs[],
                                              int nrhs,
                                              mxArray * prhs[]) {
    mxArray * mprhs[3];
    int i;
    if (nlhs > 0) {
        mlfError(
          mxCreateString(
            "Run-time Error: File: recarga_2_3/StayDpth_CreateFcn Line: 166"
            "4 Column: 1 The function \"recarga_2_3/StayDpth_CreateFcn\" wa"
            "s called with more than the declared number of outputs (0)."),
          NULL);
    }
    if (nrhs > 3) {
        mlfError(
          mxCreateString(
            "Run-time Error: File: recarga_2_3/StayDpth_CreateFcn Line: 166"
            "4 Column: 1 The function \"recarga_2_3/StayDpth_CreateFcn\" wa"
            "s called with more than the declared number of inputs (3)."),
          NULL);
    }
    for (i = 0; i < 3 && i < nrhs; ++i) {
        mprhs[i] = prhs[i];
    }
    for (; i < 3; ++i) {
        mprhs[i] = NULL;
    }
    mlfEnterNewContext(0, 3, mprhs[0], mprhs[1], mprhs[2]);
    Mrecarga_2_3_StayDpth_CreateFcn(mprhs[0], mprhs[1], mprhs[2]);
    mlfRestorePreviousContext(0, 3, mprhs[0], mprhs[1], mprhs[2]);
}

/*
 * The function "mlfRecarga_2_3_StayDpth_Callback" contains the normal
 * interface for the "recarga_2_3/StayDpth_Callback" M-function from file
 * "u:\final_recarga6\recarga\recarga_2_3.m" (lines 1679-1689). This function
 * processes any input arguments and passes them to the implementation version
 * of the function, appearing above.
 */
static void mlfRecarga_2_3_StayDpth_Callback(mxArray * hObject,
                                             mxArray * eventdata,
                                             mxArray * handles) {
    mlfEnterNewContext(0, 3, hObject, eventdata, handles);
    Mrecarga_2_3_StayDpth_Callback(hObject, eventdata, handles);
    mlfRestorePreviousContext(0, 3, hObject, eventdata, handles);
}

/*
 * The function "mlxRecarga_2_3_StayDpth_Callback" contains the feval interface
 * for the "recarga_2_3/StayDpth_Callback" M-function from file
 * "u:\final_recarga6\recarga\recarga_2_3.m" (lines 1679-1689). The feval
 * function calls the implementation version of recarga_2_3/StayDpth_Callback
 * through this function. This function processes any input arguments and
 * passes them to the implementation version of the function, appearing above.
 */
static void mlxRecarga_2_3_StayDpth_Callback(int nlhs,
                                             mxArray * plhs[],
                                             int nrhs,
                                             mxArray * prhs[]) {
    mxArray * mprhs[3];
    int i;
    if (nlhs > 0) {
        mlfError(
          mxCreateString(
            "Run-time Error: File: recarga_2_3/StayDpth_Callback Line: 167"
            "9 Column: 1 The function \"recarga_2_3/StayDpth_Callback\" wa"
            "s called with more than the declared number of outputs (0)."),
          NULL);
    }
    if (nrhs > 3) {
        mlfError(
          mxCreateString(
            "Run-time Error: File: recarga_2_3/StayDpth_Callback Line: 167"
            "9 Column: 1 The function \"recarga_2_3/StayDpth_Callback\" wa"
            "s called with more than the declared number of inputs (3)."),
          NULL);
    }
    for (i = 0; i < 3 && i < nrhs; ++i) {
        mprhs[i] = prhs[i];
    }
    for (; i < 3; ++i) {
        mprhs[i] = NULL;
    }
    mlfEnterNewContext(0, 3, mprhs[0], mprhs[1], mprhs[2]);
    Mrecarga_2_3_StayDpth_Callback(mprhs[0], mprhs[1], mprhs[2]);
    mlfRestorePreviousContext(0, 3, mprhs[0], mprhs[1], mprhs[2]);
}

/*
 * The function "mlfRecarga_2_3_Summary_Callback" contains the normal interface
 * for the "recarga_2_3/Summary_Callback" M-function from file
 * "u:\final_recarga6\recarga\recarga_2_3.m" (lines 1689-1698). This function
 * processes any input arguments and passes them to the implementation version
 * of the function, appearing above.
 */
static void mlfRecarga_2_3_Summary_Callback(mxArray * hObject,
                                            mxArray * eventdata,
                                            mxArray * handles) {
    mlfEnterNewContext(0, 3, hObject, eventdata, handles);
    Mrecarga_2_3_Summary_Callback(hObject, eventdata, handles);
    mlfRestorePreviousContext(0, 3, hObject, eventdata, handles);
}

/*
 * The function "mlxRecarga_2_3_Summary_Callback" contains the feval interface
 * for the "recarga_2_3/Summary_Callback" M-function from file
 * "u:\final_recarga6\recarga\recarga_2_3.m" (lines 1689-1698). The feval
 * function calls the implementation version of recarga_2_3/Summary_Callback
 * through this function. This function processes any input arguments and
 * passes them to the implementation version of the function, appearing above.
 */
static void mlxRecarga_2_3_Summary_Callback(int nlhs,
                                            mxArray * plhs[],
                                            int nrhs,
                                            mxArray * prhs[]) {
    mxArray * mprhs[3];
    int i;
    if (nlhs > 0) {
        mlfError(
          mxCreateString(
            "Run-time Error: File: recarga_2_3/Summary_Callback Line: 1689"
            " Column: 1 The function \"recarga_2_3/Summary_Callback\" was "
            "called with more than the declared number of outputs (0)."),
          NULL);
    }
    if (nrhs > 3) {
        mlfError(
          mxCreateString(
            "Run-time Error: File: recarga_2_3/Summary_Callback Line: 168"
            "9 Column: 1 The function \"recarga_2_3/Summary_Callback\" wa"
            "s called with more than the declared number of inputs (3)."),
          NULL);
    }
    for (i = 0; i < 3 && i < nrhs; ++i) {
        mprhs[i] = prhs[i];
    }
    for (; i < 3; ++i) {
        mprhs[i] = NULL;
    }
    mlfEnterNewContext(0, 3, mprhs[0], mprhs[1], mprhs[2]);
    Mrecarga_2_3_Summary_Callback(mprhs[0], mprhs[1], mprhs[2]);
    mlfRestorePreviousContext(0, 3, mprhs[0], mprhs[1], mprhs[2]);
}

/*
 * The function "mlfRecarga_2_3_Record_Callback" contains the normal interface
 * for the "recarga_2_3/Record_Callback" M-function from file
 * "u:\final_recarga6\recarga\recarga_2_3.m" (lines 1698-1707). This function
 * processes any input arguments and passes them to the implementation version
 * of the function, appearing above.
 */
static void mlfRecarga_2_3_Record_Callback(mxArray * hObject,
                                           mxArray * eventdata,
                                           mxArray * handles) {
    mlfEnterNewContext(0, 3, hObject, eventdata, handles);
    Mrecarga_2_3_Record_Callback(hObject, eventdata, handles);
    mlfRestorePreviousContext(0, 3, hObject, eventdata, handles);
}

/*
 * The function "mlxRecarga_2_3_Record_Callback" contains the feval interface
 * for the "recarga_2_3/Record_Callback" M-function from file
 * "u:\final_recarga6\recarga\recarga_2_3.m" (lines 1698-1707). The feval
 * function calls the implementation version of recarga_2_3/Record_Callback
 * through this function. This function processes any input arguments and
 * passes them to the implementation version of the function, appearing above.
 */
static void mlxRecarga_2_3_Record_Callback(int nlhs,
                                           mxArray * plhs[],
                                           int nrhs,
                                           mxArray * prhs[]) {
    mxArray * mprhs[3];
    int i;
    if (nlhs > 0) {
        mlfError(
          mxCreateString(
            "Run-time Error: File: recarga_2_3/Record_Callback Line: 1698"
            " Column: 1 The function \"recarga_2_3/Record_Callback\" was "
            "called with more than the declared number of outputs (0)."),
          NULL);
    }
    if (nrhs > 3) {
        mlfError(
          mxCreateString(
            "Run-time Error: File: recarga_2_3/Record_Callback Line: 1698"
            " Column: 1 The function \"recarga_2_3/Record_Callback\" was "
            "called with more than the declared number of inputs (3)."),
          NULL);
    }
    for (i = 0; i < 3 && i < nrhs; ++i) {
        mprhs[i] = prhs[i];
    }
    for (; i < 3; ++i) {
        mprhs[i] = NULL;
    }
    mlfEnterNewContext(0, 3, mprhs[0], mprhs[1], mprhs[2]);
    Mrecarga_2_3_Record_Callback(mprhs[0], mprhs[1], mprhs[2]);
    mlfRestorePreviousContext(0, 3, mprhs[0], mprhs[1], mprhs[2]);
}

/*
 * The function "mlfRecarga_2_3_edit67_CreateFcn" contains the normal interface
 * for the "recarga_2_3/edit67_CreateFcn" M-function from file
 * "u:\final_recarga6\recarga\recarga_2_3.m" (lines 1707-1722). This function
 * processes any input arguments and passes them to the implementation version
 * of the function, appearing above.
 */
static void mlfRecarga_2_3_edit67_CreateFcn(mxArray * hObject,
                                            mxArray * eventdata,
                                            mxArray * handles) {
    mlfEnterNewContext(0, 3, hObject, eventdata, handles);
    Mrecarga_2_3_edit67_CreateFcn(hObject, eventdata, handles);
    mlfRestorePreviousContext(0, 3, hObject, eventdata, handles);
}

/*
 * The function "mlxRecarga_2_3_edit67_CreateFcn" contains the feval interface
 * for the "recarga_2_3/edit67_CreateFcn" M-function from file
 * "u:\final_recarga6\recarga\recarga_2_3.m" (lines 1707-1722). The feval
 * function calls the implementation version of recarga_2_3/edit67_CreateFcn
 * through this function. This function processes any input arguments and
 * passes them to the implementation version of the function, appearing above.
 */
static void mlxRecarga_2_3_edit67_CreateFcn(int nlhs,
                                            mxArray * plhs[],
                                            int nrhs,
                                            mxArray * prhs[]) {
    mxArray * mprhs[3];
    int i;
    if (nlhs > 0) {
        mlfError(
          mxCreateString(
            "Run-time Error: File: recarga_2_3/edit67_CreateFcn Line: 1707"
            " Column: 1 The function \"recarga_2_3/edit67_CreateFcn\" was "
            "called with more than the declared number of outputs (0)."),
          NULL);
    }
    if (nrhs > 3) {
        mlfError(
          mxCreateString(
            "Run-time Error: File: recarga_2_3/edit67_CreateFcn Line: 170"
            "7 Column: 1 The function \"recarga_2_3/edit67_CreateFcn\" wa"
            "s called with more than the declared number of inputs (3)."),
          NULL);
    }
    for (i = 0; i < 3 && i < nrhs; ++i) {
        mprhs[i] = prhs[i];
    }
    for (; i < 3; ++i) {
        mprhs[i] = NULL;
    }
    mlfEnterNewContext(0, 3, mprhs[0], mprhs[1], mprhs[2]);
    Mrecarga_2_3_edit67_CreateFcn(mprhs[0], mprhs[1], mprhs[2]);
    mlfRestorePreviousContext(0, 3, mprhs[0], mprhs[1], mprhs[2]);
}

/*
 * The function "mlfRecarga_2_3_edit67_Callback" contains the normal interface
 * for the "recarga_2_3/edit67_Callback" M-function from file
 * "u:\final_recarga6\recarga\recarga_2_3.m" (lines 1722-1732). This function
 * processes any input arguments and passes them to the implementation version
 * of the function, appearing above.
 */
static void mlfRecarga_2_3_edit67_Callback(mxArray * hObject,
                                           mxArray * eventdata,
                                           mxArray * handles) {
    mlfEnterNewContext(0, 3, hObject, eventdata, handles);
    Mrecarga_2_3_edit67_Callback(hObject, eventdata, handles);
    mlfRestorePreviousContext(0, 3, hObject, eventdata, handles);
}

/*
 * The function "mlxRecarga_2_3_edit67_Callback" contains the feval interface
 * for the "recarga_2_3/edit67_Callback" M-function from file
 * "u:\final_recarga6\recarga\recarga_2_3.m" (lines 1722-1732). The feval
 * function calls the implementation version of recarga_2_3/edit67_Callback
 * through this function. This function processes any input arguments and
 * passes them to the implementation version of the function, appearing above.
 */
static void mlxRecarga_2_3_edit67_Callback(int nlhs,
                                           mxArray * plhs[],
                                           int nrhs,
                                           mxArray * prhs[]) {
    mxArray * mprhs[3];
    int i;
    if (nlhs > 0) {
        mlfError(
          mxCreateString(
            "Run-time Error: File: recarga_2_3/edit67_Callback Line: 1722"
            " Column: 1 The function \"recarga_2_3/edit67_Callback\" was "
            "called with more than the declared number of outputs (0)."),
          NULL);
    }
    if (nrhs > 3) {
        mlfError(
          mxCreateString(
            "Run-time Error: File: recarga_2_3/edit67_Callback Line: 1722"
            " Column: 1 The function \"recarga_2_3/edit67_Callback\" was "
            "called with more than the declared number of inputs (3)."),
          NULL);
    }
    for (i = 0; i < 3 && i < nrhs; ++i) {
        mprhs[i] = prhs[i];
    }
    for (; i < 3; ++i) {
        mprhs[i] = NULL;
    }
    mlfEnterNewContext(0, 3, mprhs[0], mprhs[1], mprhs[2]);
    Mrecarga_2_3_edit67_Callback(mprhs[0], mprhs[1], mprhs[2]);
    mlfRestorePreviousContext(0, 3, mprhs[0], mprhs[1], mprhs[2]);
}

/*
 * The function "mlfRecarga_2_3_precip_CreateFcn" contains the normal interface
 * for the "recarga_2_3/precip_CreateFcn" M-function from file
 * "u:\final_recarga6\recarga\recarga_2_3.m" (lines 1732-1747). This function
 * processes any input arguments and passes them to the implementation version
 * of the function, appearing above.
 */
static void mlfRecarga_2_3_precip_CreateFcn(mxArray * hObject,
                                            mxArray * eventdata,
                                            mxArray * handles) {
    mlfEnterNewContext(0, 3, hObject, eventdata, handles);
    Mrecarga_2_3_precip_CreateFcn(hObject, eventdata, handles);
    mlfRestorePreviousContext(0, 3, hObject, eventdata, handles);
}

/*
 * The function "mlxRecarga_2_3_precip_CreateFcn" contains the feval interface
 * for the "recarga_2_3/precip_CreateFcn" M-function from file
 * "u:\final_recarga6\recarga\recarga_2_3.m" (lines 1732-1747). The feval
 * function calls the implementation version of recarga_2_3/precip_CreateFcn
 * through this function. This function processes any input arguments and
 * passes them to the implementation version of the function, appearing above.
 */
static void mlxRecarga_2_3_precip_CreateFcn(int nlhs,
                                            mxArray * plhs[],
                                            int nrhs,
                                            mxArray * prhs[]) {
    mxArray * mprhs[3];
    int i;
    if (nlhs > 0) {
        mlfError(
          mxCreateString(
            "Run-time Error: File: recarga_2_3/precip_CreateFcn Line: 1732"
            " Column: 1 The function \"recarga_2_3/precip_CreateFcn\" was "
            "called with more than the declared number of outputs (0)."),
          NULL);
    }
    if (nrhs > 3) {
        mlfError(
          mxCreateString(
            "Run-time Error: File: recarga_2_3/precip_CreateFcn Line: 173"
            "2 Column: 1 The function \"recarga_2_3/precip_CreateFcn\" wa"
            "s called with more than the declared number of inputs (3)."),
          NULL);
    }
    for (i = 0; i < 3 && i < nrhs; ++i) {
        mprhs[i] = prhs[i];
    }
    for (; i < 3; ++i) {
        mprhs[i] = NULL;
    }
    mlfEnterNewContext(0, 3, mprhs[0], mprhs[1], mprhs[2]);
    Mrecarga_2_3_precip_CreateFcn(mprhs[0], mprhs[1], mprhs[2]);
    mlfRestorePreviousContext(0, 3, mprhs[0], mprhs[1], mprhs[2]);
}

/*
 * The function "mlfRecarga_2_3_precip_Callback" contains the normal interface
 * for the "recarga_2_3/precip_Callback" M-function from file
 * "u:\final_recarga6\recarga\recarga_2_3.m" (lines 1747-1757). This function
 * processes any input arguments and passes them to the implementation version
 * of the function, appearing above.
 */
static void mlfRecarga_2_3_precip_Callback(mxArray * hObject,
                                           mxArray * eventdata,
                                           mxArray * handles) {
    mlfEnterNewContext(0, 3, hObject, eventdata, handles);
    Mrecarga_2_3_precip_Callback(hObject, eventdata, handles);
    mlfRestorePreviousContext(0, 3, hObject, eventdata, handles);
}

/*
 * The function "mlxRecarga_2_3_precip_Callback" contains the feval interface
 * for the "recarga_2_3/precip_Callback" M-function from file
 * "u:\final_recarga6\recarga\recarga_2_3.m" (lines 1747-1757). The feval
 * function calls the implementation version of recarga_2_3/precip_Callback
 * through this function. This function processes any input arguments and
 * passes them to the implementation version of the function, appearing above.
 */
static void mlxRecarga_2_3_precip_Callback(int nlhs,
                                           mxArray * plhs[],
                                           int nrhs,
                                           mxArray * prhs[]) {
    mxArray * mprhs[3];
    int i;
    if (nlhs > 0) {
        mlfError(
          mxCreateString(
            "Run-time Error: File: recarga_2_3/precip_Callback Line: 1747"
            " Column: 1 The function \"recarga_2_3/precip_Callback\" was "
            "called with more than the declared number of outputs (0)."),
          NULL);
    }
    if (nrhs > 3) {
        mlfError(
          mxCreateString(
            "Run-time Error: File: recarga_2_3/precip_Callback Line: 1747"
            " Column: 1 The function \"recarga_2_3/precip_Callback\" was "
            "called with more than the declared number of inputs (3)."),
          NULL);
    }
    for (i = 0; i < 3 && i < nrhs; ++i) {
        mprhs[i] = prhs[i];
    }
    for (; i < 3; ++i) {
        mprhs[i] = NULL;
    }
    mlfEnterNewContext(0, 3, mprhs[0], mprhs[1], mprhs[2]);
    Mrecarga_2_3_precip_Callback(mprhs[0], mprhs[1], mprhs[2]);
    mlfRestorePreviousContext(0, 3, mprhs[0], mprhs[1], mprhs[2]);
}

/*
 * The function "mlfRecarga_2_3_SimType_CreateFcn" contains the normal
 * interface for the "recarga_2_3/SimType_CreateFcn" M-function from file
 * "u:\final_recarga6\recarga\recarga_2_3.m" (lines 1757-1772). This function
 * processes any input arguments and passes them to the implementation version
 * of the function, appearing above.
 */
static void mlfRecarga_2_3_SimType_CreateFcn(mxArray * hObject,
                                             mxArray * eventdata,
                                             mxArray * handles) {
    mlfEnterNewContext(0, 3, hObject, eventdata, handles);
    Mrecarga_2_3_SimType_CreateFcn(hObject, eventdata, handles);
    mlfRestorePreviousContext(0, 3, hObject, eventdata, handles);
}

/*
 * The function "mlxRecarga_2_3_SimType_CreateFcn" contains the feval interface
 * for the "recarga_2_3/SimType_CreateFcn" M-function from file
 * "u:\final_recarga6\recarga\recarga_2_3.m" (lines 1757-1772). The feval
 * function calls the implementation version of recarga_2_3/SimType_CreateFcn
 * through this function. This function processes any input arguments and
 * passes them to the implementation version of the function, appearing above.
 */
static void mlxRecarga_2_3_SimType_CreateFcn(int nlhs,
                                             mxArray * plhs[],
                                             int nrhs,
                                             mxArray * prhs[]) {
    mxArray * mprhs[3];
    int i;
    if (nlhs > 0) {
        mlfError(
          mxCreateString(
            "Run-time Error: File: recarga_2_3/SimType_CreateFcn Line: 175"
            "7 Column: 1 The function \"recarga_2_3/SimType_CreateFcn\" wa"
            "s called with more than the declared number of outputs (0)."),
          NULL);
    }
    if (nrhs > 3) {
        mlfError(
          mxCreateString(
            "Run-time Error: File: recarga_2_3/SimType_CreateFcn Line: 175"
            "7 Column: 1 The function \"recarga_2_3/SimType_CreateFcn\" wa"
            "s called with more than the declared number of inputs (3)."),
          NULL);
    }
    for (i = 0; i < 3 && i < nrhs; ++i) {
        mprhs[i] = prhs[i];
    }
    for (; i < 3; ++i) {
        mprhs[i] = NULL;
    }
    mlfEnterNewContext(0, 3, mprhs[0], mprhs[1], mprhs[2]);
    Mrecarga_2_3_SimType_CreateFcn(mprhs[0], mprhs[1], mprhs[2]);
    mlfRestorePreviousContext(0, 3, mprhs[0], mprhs[1], mprhs[2]);
}

/*
 * The function "mlfRecarga_2_3_SimType_Callback" contains the normal interface
 * for the "recarga_2_3/SimType_Callback" M-function from file
 * "u:\final_recarga6\recarga\recarga_2_3.m" (lines 1772-1795). This function
 * processes any input arguments and passes them to the implementation version
 * of the function, appearing above.
 */
static void mlfRecarga_2_3_SimType_Callback(mxArray * hObject,
                                            mxArray * eventdata,
                                            mxArray * handles) {
    mlfEnterNewContext(0, 3, hObject, eventdata, handles);
    Mrecarga_2_3_SimType_Callback(hObject, eventdata, handles);
    mlfRestorePreviousContext(0, 3, hObject, eventdata, handles);
}

/*
 * The function "mlxRecarga_2_3_SimType_Callback" contains the feval interface
 * for the "recarga_2_3/SimType_Callback" M-function from file
 * "u:\final_recarga6\recarga\recarga_2_3.m" (lines 1772-1795). The feval
 * function calls the implementation version of recarga_2_3/SimType_Callback
 * through this function. This function processes any input arguments and
 * passes them to the implementation version of the function, appearing above.
 */
static void mlxRecarga_2_3_SimType_Callback(int nlhs,
                                            mxArray * plhs[],
                                            int nrhs,
                                            mxArray * prhs[]) {
    mxArray * mprhs[3];
    int i;
    if (nlhs > 0) {
        mlfError(
          mxCreateString(
            "Run-time Error: File: recarga_2_3/SimType_Callback Line: 1772"
            " Column: 1 The function \"recarga_2_3/SimType_Callback\" was "
            "called with more than the declared number of outputs (0)."),
          NULL);
    }
    if (nrhs > 3) {
        mlfError(
          mxCreateString(
            "Run-time Error: File: recarga_2_3/SimType_Callback Line: 177"
            "2 Column: 1 The function \"recarga_2_3/SimType_Callback\" wa"
            "s called with more than the declared number of inputs (3)."),
          NULL);
    }
    for (i = 0; i < 3 && i < nrhs; ++i) {
        mprhs[i] = prhs[i];
    }
    for (; i < 3; ++i) {
        mprhs[i] = NULL;
    }
    mlfEnterNewContext(0, 3, mprhs[0], mprhs[1], mprhs[2]);
    Mrecarga_2_3_SimType_Callback(mprhs[0], mprhs[1], mprhs[2]);
    mlfRestorePreviousContext(0, 3, mprhs[0], mprhs[1], mprhs[2]);
}

/*
 * The function "mlfRecarga_2_3_PptType_CreateFcn" contains the normal
 * interface for the "recarga_2_3/PptType_CreateFcn" M-function from file
 * "u:\final_recarga6\recarga\recarga_2_3.m" (lines 1795-1810). This function
 * processes any input arguments and passes them to the implementation version
 * of the function, appearing above.
 */
static void mlfRecarga_2_3_PptType_CreateFcn(mxArray * hObject,
                                             mxArray * eventdata,
                                             mxArray * handles) {
    mlfEnterNewContext(0, 3, hObject, eventdata, handles);
    Mrecarga_2_3_PptType_CreateFcn(hObject, eventdata, handles);
    mlfRestorePreviousContext(0, 3, hObject, eventdata, handles);
}

/*
 * The function "mlxRecarga_2_3_PptType_CreateFcn" contains the feval interface
 * for the "recarga_2_3/PptType_CreateFcn" M-function from file
 * "u:\final_recarga6\recarga\recarga_2_3.m" (lines 1795-1810). The feval
 * function calls the implementation version of recarga_2_3/PptType_CreateFcn
 * through this function. This function processes any input arguments and
 * passes them to the implementation version of the function, appearing above.
 */
static void mlxRecarga_2_3_PptType_CreateFcn(int nlhs,
                                             mxArray * plhs[],
                                             int nrhs,
                                             mxArray * prhs[]) {
    mxArray * mprhs[3];
    int i;
    if (nlhs > 0) {
        mlfError(
          mxCreateString(
            "Run-time Error: File: recarga_2_3/PptType_CreateFcn Line: 179"
            "5 Column: 1 The function \"recarga_2_3/PptType_CreateFcn\" wa"
            "s called with more than the declared number of outputs (0)."),
          NULL);
    }
    if (nrhs > 3) {
        mlfError(
          mxCreateString(
            "Run-time Error: File: recarga_2_3/PptType_CreateFcn Line: 179"
            "5 Column: 1 The function \"recarga_2_3/PptType_CreateFcn\" wa"
            "s called with more than the declared number of inputs (3)."),
          NULL);
    }
    for (i = 0; i < 3 && i < nrhs; ++i) {
        mprhs[i] = prhs[i];
    }
    for (; i < 3; ++i) {
        mprhs[i] = NULL;
    }
    mlfEnterNewContext(0, 3, mprhs[0], mprhs[1], mprhs[2]);
    Mrecarga_2_3_PptType_CreateFcn(mprhs[0], mprhs[1], mprhs[2]);
    mlfRestorePreviousContext(0, 3, mprhs[0], mprhs[1], mprhs[2]);
}

/*
 * The function "mlfRecarga_2_3_PptType_Callback" contains the normal interface
 * for the "recarga_2_3/PptType_Callback" M-function from file
 * "u:\final_recarga6\recarga\recarga_2_3.m" (lines 1810-1820). This function
 * processes any input arguments and passes them to the implementation version
 * of the function, appearing above.
 */
static void mlfRecarga_2_3_PptType_Callback(mxArray * hObject,
                                            mxArray * eventdata,
                                            mxArray * handles) {
    mlfEnterNewContext(0, 3, hObject, eventdata, handles);
    Mrecarga_2_3_PptType_Callback(hObject, eventdata, handles);
    mlfRestorePreviousContext(0, 3, hObject, eventdata, handles);
}

/*
 * The function "mlxRecarga_2_3_PptType_Callback" contains the feval interface
 * for the "recarga_2_3/PptType_Callback" M-function from file
 * "u:\final_recarga6\recarga\recarga_2_3.m" (lines 1810-1820). The feval
 * function calls the implementation version of recarga_2_3/PptType_Callback
 * through this function. This function processes any input arguments and
 * passes them to the implementation version of the function, appearing above.
 */
static void mlxRecarga_2_3_PptType_Callback(int nlhs,
                                            mxArray * plhs[],
                                            int nrhs,
                                            mxArray * prhs[]) {
    mxArray * mprhs[3];
    int i;
    if (nlhs > 0) {
        mlfError(
          mxCreateString(
            "Run-time Error: File: recarga_2_3/PptType_Callback Line: 1810"
            " Column: 1 The function \"recarga_2_3/PptType_Callback\" was "
            "called with more than the declared number of outputs (0)."),
          NULL);
    }
    if (nrhs > 3) {
        mlfError(
          mxCreateString(
            "Run-time Error: File: recarga_2_3/PptType_Callback Line: 181"
            "0 Column: 1 The function \"recarga_2_3/PptType_Callback\" wa"
            "s called with more than the declared number of inputs (3)."),
          NULL);
    }
    for (i = 0; i < 3 && i < nrhs; ++i) {
        mprhs[i] = prhs[i];
    }
    for (; i < 3; ++i) {
        mprhs[i] = NULL;
    }
    mlfEnterNewContext(0, 3, mprhs[0], mprhs[1], mprhs[2]);
    Mrecarga_2_3_PptType_Callback(mprhs[0], mprhs[1], mprhs[2]);
    mlfRestorePreviousContext(0, 3, mprhs[0], mprhs[1], mprhs[2]);
}

/*
 * The function "mlfRecarga_2_3_PptDepth_CreateFcn" contains the normal
 * interface for the "recarga_2_3/PptDepth_CreateFcn" M-function from file
 * "u:\final_recarga6\recarga\recarga_2_3.m" (lines 1820-1835). This function
 * processes any input arguments and passes them to the implementation version
 * of the function, appearing above.
 */
static void mlfRecarga_2_3_PptDepth_CreateFcn(mxArray * hObject,
                                              mxArray * eventdata,
                                              mxArray * handles) {
    mlfEnterNewContext(0, 3, hObject, eventdata, handles);
    Mrecarga_2_3_PptDepth_CreateFcn(hObject, eventdata, handles);
    mlfRestorePreviousContext(0, 3, hObject, eventdata, handles);
}

/*
 * The function "mlxRecarga_2_3_PptDepth_CreateFcn" contains the feval
 * interface for the "recarga_2_3/PptDepth_CreateFcn" M-function from file
 * "u:\final_recarga6\recarga\recarga_2_3.m" (lines 1820-1835). The feval
 * function calls the implementation version of recarga_2_3/PptDepth_CreateFcn
 * through this function. This function processes any input arguments and
 * passes them to the implementation version of the function, appearing above.
 */
static void mlxRecarga_2_3_PptDepth_CreateFcn(int nlhs,
                                              mxArray * plhs[],
                                              int nrhs,
                                              mxArray * prhs[]) {
    mxArray * mprhs[3];
    int i;
    if (nlhs > 0) {
        mlfError(
          mxCreateString(
            "Run-time Error: File: recarga_2_3/PptDepth_CreateFcn Line: 182"
            "0 Column: 1 The function \"recarga_2_3/PptDepth_CreateFcn\" wa"
            "s called with more than the declared number of outputs (0)."),
          NULL);
    }
    if (nrhs > 3) {
        mlfError(
          mxCreateString(
            "Run-time Error: File: recarga_2_3/PptDepth_CreateFcn Line: 182"
            "0 Column: 1 The function \"recarga_2_3/PptDepth_CreateFcn\" wa"
            "s called with more than the declared number of inputs (3)."),
          NULL);
    }
    for (i = 0; i < 3 && i < nrhs; ++i) {
        mprhs[i] = prhs[i];
    }
    for (; i < 3; ++i) {
        mprhs[i] = NULL;
    }
    mlfEnterNewContext(0, 3, mprhs[0], mprhs[1], mprhs[2]);
    Mrecarga_2_3_PptDepth_CreateFcn(mprhs[0], mprhs[1], mprhs[2]);
    mlfRestorePreviousContext(0, 3, mprhs[0], mprhs[1], mprhs[2]);
}

/*
 * The function "mlfRecarga_2_3_PptDepth_Callback" contains the normal
 * interface for the "recarga_2_3/PptDepth_Callback" M-function from file
 * "u:\final_recarga6\recarga\recarga_2_3.m" (lines 1835-1848). This function
 * processes any input arguments and passes them to the implementation version
 * of the function, appearing above.
 */
static void mlfRecarga_2_3_PptDepth_Callback(mxArray * hObject,
                                             mxArray * eventdata,
                                             mxArray * handles) {
    mlfEnterNewContext(0, 3, hObject, eventdata, handles);
    Mrecarga_2_3_PptDepth_Callback(hObject, eventdata, handles);
    mlfRestorePreviousContext(0, 3, hObject, eventdata, handles);
}

/*
 * The function "mlxRecarga_2_3_PptDepth_Callback" contains the feval interface
 * for the "recarga_2_3/PptDepth_Callback" M-function from file
 * "u:\final_recarga6\recarga\recarga_2_3.m" (lines 1835-1848). The feval
 * function calls the implementation version of recarga_2_3/PptDepth_Callback
 * through this function. This function processes any input arguments and
 * passes them to the implementation version of the function, appearing above.
 */
static void mlxRecarga_2_3_PptDepth_Callback(int nlhs,
                                             mxArray * plhs[],
                                             int nrhs,
                                             mxArray * prhs[]) {
    mxArray * mprhs[3];
    int i;
    if (nlhs > 0) {
        mlfError(
          mxCreateString(
            "Run-time Error: File: recarga_2_3/PptDepth_Callback Line: 183"
            "5 Column: 1 The function \"recarga_2_3/PptDepth_Callback\" wa"
            "s called with more than the declared number of outputs (0)."),
          NULL);
    }
    if (nrhs > 3) {
        mlfError(
          mxCreateString(
            "Run-time Error: File: recarga_2_3/PptDepth_Callback Line: 183"
            "5 Column: 1 The function \"recarga_2_3/PptDepth_Callback\" wa"
            "s called with more than the declared number of inputs (3)."),
          NULL);
    }
    for (i = 0; i < 3 && i < nrhs; ++i) {
        mprhs[i] = prhs[i];
    }
    for (; i < 3; ++i) {
        mprhs[i] = NULL;
    }
    mlfEnterNewContext(0, 3, mprhs[0], mprhs[1], mprhs[2]);
    Mrecarga_2_3_PptDepth_Callback(mprhs[0], mprhs[1], mprhs[2]);
    mlfRestorePreviousContext(0, 3, mprhs[0], mprhs[1], mprhs[2]);
}

/*
 * The function "mlfRecarga_2_3_Units_CreateFcn" contains the normal interface
 * for the "recarga_2_3/Units_CreateFcn" M-function from file
 * "u:\final_recarga6\recarga\recarga_2_3.m" (lines 1848-1863). This function
 * processes any input arguments and passes them to the implementation version
 * of the function, appearing above.
 */
static void mlfRecarga_2_3_Units_CreateFcn(mxArray * hObject,
                                           mxArray * eventdata,
                                           mxArray * handles) {
    mlfEnterNewContext(0, 3, hObject, eventdata, handles);
    Mrecarga_2_3_Units_CreateFcn(hObject, eventdata, handles);
    mlfRestorePreviousContext(0, 3, hObject, eventdata, handles);
}

/*
 * The function "mlxRecarga_2_3_Units_CreateFcn" contains the feval interface
 * for the "recarga_2_3/Units_CreateFcn" M-function from file
 * "u:\final_recarga6\recarga\recarga_2_3.m" (lines 1848-1863). The feval
 * function calls the implementation version of recarga_2_3/Units_CreateFcn
 * through this function. This function processes any input arguments and
 * passes them to the implementation version of the function, appearing above.
 */
static void mlxRecarga_2_3_Units_CreateFcn(int nlhs,
                                           mxArray * plhs[],
                                           int nrhs,
                                           mxArray * prhs[]) {
    mxArray * mprhs[3];
    int i;
    if (nlhs > 0) {
        mlfError(
          mxCreateString(
            "Run-time Error: File: recarga_2_3/Units_CreateFcn Line: 1848"
            " Column: 1 The function \"recarga_2_3/Units_CreateFcn\" was "
            "called with more than the declared number of outputs (0)."),
          NULL);
    }
    if (nrhs > 3) {
        mlfError(
          mxCreateString(
            "Run-time Error: File: recarga_2_3/Units_CreateFcn Line: 1848"
            " Column: 1 The function \"recarga_2_3/Units_CreateFcn\" was "
            "called with more than the declared number of inputs (3)."),
          NULL);
    }
    for (i = 0; i < 3 && i < nrhs; ++i) {
        mprhs[i] = prhs[i];
    }
    for (; i < 3; ++i) {
        mprhs[i] = NULL;
    }
    mlfEnterNewContext(0, 3, mprhs[0], mprhs[1], mprhs[2]);
    Mrecarga_2_3_Units_CreateFcn(mprhs[0], mprhs[1], mprhs[2]);
    mlfRestorePreviousContext(0, 3, mprhs[0], mprhs[1], mprhs[2]);
}

/*
 * The function "mlfRecarga_2_3_Units_Callback" contains the normal interface
 * for the "recarga_2_3/Units_Callback" M-function from file
 * "u:\final_recarga6\recarga\recarga_2_3.m" (lines 1863-1940). This function
 * processes any input arguments and passes them to the implementation version
 * of the function, appearing above.
 */
static void mlfRecarga_2_3_Units_Callback(mxArray * hObject,
                                          mxArray * eventdata,
                                          mxArray * handles) {
    mlfEnterNewContext(0, 3, hObject, eventdata, handles);
    Mrecarga_2_3_Units_Callback(hObject, eventdata, handles);
    mlfRestorePreviousContext(0, 3, hObject, eventdata, handles);
}

/*
 * The function "mlxRecarga_2_3_Units_Callback" contains the feval interface
 * for the "recarga_2_3/Units_Callback" M-function from file
 * "u:\final_recarga6\recarga\recarga_2_3.m" (lines 1863-1940). The feval
 * function calls the implementation version of recarga_2_3/Units_Callback
 * through this function. This function processes any input arguments and
 * passes them to the implementation version of the function, appearing above.
 */
static void mlxRecarga_2_3_Units_Callback(int nlhs,
                                          mxArray * plhs[],
                                          int nrhs,
                                          mxArray * prhs[]) {
    mxArray * mprhs[3];
    int i;
    if (nlhs > 0) {
        mlfError(
          mxCreateString(
            "Run-time Error: File: recarga_2_3/Units_Callback Line: 1863"
            " Column: 1 The function \"recarga_2_3/Units_Callback\" was "
            "called with more than the declared number of outputs (0)."),
          NULL);
    }
    if (nrhs > 3) {
        mlfError(
          mxCreateString(
            "Run-time Error: File: recarga_2_3/Units_Callback Line: 1863"
            " Column: 1 The function \"recarga_2_3/Units_Callback\" was "
            "called with more than the declared number of inputs (3)."),
          NULL);
    }
    for (i = 0; i < 3 && i < nrhs; ++i) {
        mprhs[i] = prhs[i];
    }
    for (; i < 3; ++i) {
        mprhs[i] = NULL;
    }
    mlfEnterNewContext(0, 3, mprhs[0], mprhs[1], mprhs[2]);
    Mrecarga_2_3_Units_Callback(mprhs[0], mprhs[1], mprhs[2]);
    mlfRestorePreviousContext(0, 3, mprhs[0], mprhs[1], mprhs[2]);
}

/*
 * The function "mlfRecarga_2_3_CurrentUnit_CreateFcn" contains the normal
 * interface for the "recarga_2_3/CurrentUnit_CreateFcn" M-function from file
 * "u:\final_recarga6\recarga\recarga_2_3.m" (lines 1940-1955). This function
 * processes any input arguments and passes them to the implementation version
 * of the function, appearing above.
 */
static void mlfRecarga_2_3_CurrentUnit_CreateFcn(mxArray * hObject,
                                                 mxArray * eventdata,
                                                 mxArray * handles) {
    mlfEnterNewContext(0, 3, hObject, eventdata, handles);
    Mrecarga_2_3_CurrentUnit_CreateFcn(hObject, eventdata, handles);
    mlfRestorePreviousContext(0, 3, hObject, eventdata, handles);
}

/*
 * The function "mlxRecarga_2_3_CurrentUnit_CreateFcn" contains the feval
 * interface for the "recarga_2_3/CurrentUnit_CreateFcn" M-function from file
 * "u:\final_recarga6\recarga\recarga_2_3.m" (lines 1940-1955). The feval
 * function calls the implementation version of
 * recarga_2_3/CurrentUnit_CreateFcn through this function. This function
 * processes any input arguments and passes them to the implementation version
 * of the function, appearing above.
 */
static void mlxRecarga_2_3_CurrentUnit_CreateFcn(int nlhs,
                                                 mxArray * plhs[],
                                                 int nrhs,
                                                 mxArray * prhs[]) {
    mxArray * mprhs[3];
    int i;
    if (nlhs > 0) {
        mlfError(
          mxCreateString(
            "Run-time Error: File: recarga_2_3/CurrentUnit_CreateFcn Line: 19"
            "40 Column: 1 The function \"recarga_2_3/CurrentUnit_CreateFcn\" "
            "was called with more than the declared number of outputs (0)."),
          NULL);
    }
    if (nrhs > 3) {
        mlfError(
          mxCreateString(
            "Run-time Error: File: recarga_2_3/CurrentUnit_CreateFcn Line: 19"
            "40 Column: 1 The function \"recarga_2_3/CurrentUnit_CreateFcn\" "
            "was called with more than the declared number of inputs (3)."),
          NULL);
    }
    for (i = 0; i < 3 && i < nrhs; ++i) {
        mprhs[i] = prhs[i];
    }
    for (; i < 3; ++i) {
        mprhs[i] = NULL;
    }
    mlfEnterNewContext(0, 3, mprhs[0], mprhs[1], mprhs[2]);
    Mrecarga_2_3_CurrentUnit_CreateFcn(mprhs[0], mprhs[1], mprhs[2]);
    mlfRestorePreviousContext(0, 3, mprhs[0], mprhs[1], mprhs[2]);
}

/*
 * The function "mlfRecarga_2_3_CurrentUnit_Callback" contains the normal
 * interface for the "recarga_2_3/CurrentUnit_Callback" M-function from file
 * "u:\final_recarga6\recarga\recarga_2_3.m" (lines 1955-1965). This function
 * processes any input arguments and passes them to the implementation version
 * of the function, appearing above.
 */
static void mlfRecarga_2_3_CurrentUnit_Callback(mxArray * hObject,
                                                mxArray * eventdata,
                                                mxArray * handles) {
    mlfEnterNewContext(0, 3, hObject, eventdata, handles);
    Mrecarga_2_3_CurrentUnit_Callback(hObject, eventdata, handles);
    mlfRestorePreviousContext(0, 3, hObject, eventdata, handles);
}

/*
 * The function "mlxRecarga_2_3_CurrentUnit_Callback" contains the feval
 * interface for the "recarga_2_3/CurrentUnit_Callback" M-function from file
 * "u:\final_recarga6\recarga\recarga_2_3.m" (lines 1955-1965). The feval
 * function calls the implementation version of
 * recarga_2_3/CurrentUnit_Callback through this function. This function
 * processes any input arguments and passes them to the implementation version
 * of the function, appearing above.
 */
static void mlxRecarga_2_3_CurrentUnit_Callback(int nlhs,
                                                mxArray * plhs[],
                                                int nrhs,
                                                mxArray * prhs[]) {
    mxArray * mprhs[3];
    int i;
    if (nlhs > 0) {
        mlfError(
          mxCreateString(
            "Run-time Error: File: recarga_2_3/CurrentUnit_Callback Line: 19"
            "55 Column: 1 The function \"recarga_2_3/CurrentUnit_Callback\" "
            "was called with more than the declared number of outputs (0)."),
          NULL);
    }
    if (nrhs > 3) {
        mlfError(
          mxCreateString(
            "Run-time Error: File: recarga_2_3/CurrentUnit_Callback Line: 19"
            "55 Column: 1 The function \"recarga_2_3/CurrentUnit_Callback\" "
            "was called with more than the declared number of inputs (3)."),
          NULL);
    }
    for (i = 0; i < 3 && i < nrhs; ++i) {
        mprhs[i] = prhs[i];
    }
    for (; i < 3; ++i) {
        mprhs[i] = NULL;
    }
    mlfEnterNewContext(0, 3, mprhs[0], mprhs[1], mprhs[2]);
    Mrecarga_2_3_CurrentUnit_Callback(mprhs[0], mprhs[1], mprhs[2]);
    mlfRestorePreviousContext(0, 3, mprhs[0], mprhs[1], mprhs[2]);
}

/*
 * The function "mlfRecarga_2_3_Far_Callback" contains the normal interface for
 * the "recarga_2_3/Far_Callback" M-function from file
 * "u:\final_recarga6\recarga\recarga_2_3.m" (lines 1965-2196). This function
 * processes any input arguments and passes them to the implementation version
 * of the function, appearing above.
 */
static void mlfRecarga_2_3_Far_Callback(mxArray * hObject,
                                        mxArray * eventdata,
                                        mxArray * handles) {
    mlfEnterNewContext(0, 3, hObject, eventdata, handles);
    Mrecarga_2_3_Far_Callback(hObject, eventdata, handles);
    mlfRestorePreviousContext(0, 3, hObject, eventdata, handles);
}

/*
 * The function "mlxRecarga_2_3_Far_Callback" contains the feval interface for
 * the "recarga_2_3/Far_Callback" M-function from file
 * "u:\final_recarga6\recarga\recarga_2_3.m" (lines 1965-2196). The feval
 * function calls the implementation version of recarga_2_3/Far_Callback
 * through this function. This function processes any input arguments and
 * passes them to the implementation version of the function, appearing above.
 */
static void mlxRecarga_2_3_Far_Callback(int nlhs,
                                        mxArray * plhs[],
                                        int nrhs,
                                        mxArray * prhs[]) {
    mxArray * mprhs[3];
    int i;
    if (nlhs > 0) {
        mlfError(
          mxCreateString(
            "Run-time Error: File: recarga_2_3/Far_Callback Line: 1965 "
            "Column: 1 The function \"recarga_2_3/Far_Callback\" was ca"
            "lled with more than the declared number of outputs (0)."),
          NULL);
    }
    if (nrhs > 3) {
        mlfError(
          mxCreateString(
            "Run-time Error: File: recarga_2_3/Far_Callback Line: 1965 "
            "Column: 1 The function \"recarga_2_3/Far_Callback\" was ca"
            "lled with more than the declared number of inputs (3)."),
          NULL);
    }
    for (i = 0; i < 3 && i < nrhs; ++i) {
        mprhs[i] = prhs[i];
    }
    for (; i < 3; ++i) {
        mprhs[i] = NULL;
    }
    mlfEnterNewContext(0, 3, mprhs[0], mprhs[1], mprhs[2]);
    Mrecarga_2_3_Far_Callback(mprhs[0], mprhs[1], mprhs[2]);
    mlfRestorePreviousContext(0, 3, mprhs[0], mprhs[1], mprhs[2]);
}

/*
 * The function "mlfRecarga_2_3_target_stayon_CreateFcn" contains the normal
 * interface for the "recarga_2_3/target_stayon_CreateFcn" M-function from file
 * "u:\final_recarga6\recarga\recarga_2_3.m" (lines 2196-2211). This function
 * processes any input arguments and passes them to the implementation version
 * of the function, appearing above.
 */
static void mlfRecarga_2_3_target_stayon_CreateFcn(mxArray * hObject,
                                                   mxArray * eventdata,
                                                   mxArray * handles) {
    mlfEnterNewContext(0, 3, hObject, eventdata, handles);
    Mrecarga_2_3_target_stayon_CreateFcn(hObject, eventdata, handles);
    mlfRestorePreviousContext(0, 3, hObject, eventdata, handles);
}

/*
 * The function "mlxRecarga_2_3_target_stayon_CreateFcn" contains the feval
 * interface for the "recarga_2_3/target_stayon_CreateFcn" M-function from file
 * "u:\final_recarga6\recarga\recarga_2_3.m" (lines 2196-2211). The feval
 * function calls the implementation version of
 * recarga_2_3/target_stayon_CreateFcn through this function. This function
 * processes any input arguments and passes them to the implementation version
 * of the function, appearing above.
 */
static void mlxRecarga_2_3_target_stayon_CreateFcn(int nlhs,
                                                   mxArray * plhs[],
                                                   int nrhs,
                                                   mxArray * prhs[]) {
    mxArray * mprhs[3];
    int i;
    if (nlhs > 0) {
        mlfError(
          mxCreateString(
            "Run-time Error: File: recarga_2_3/target_stayon_CreateFcn Line: 21"
            "96 Column: 1 The function \"recarga_2_3/target_stayon_CreateFcn\" "
            "was called with more than the declared number of outputs (0)."),
          NULL);
    }
    if (nrhs > 3) {
        mlfError(
          mxCreateString(
            "Run-time Error: File: recarga_2_3/target_stayon_CreateFcn Line: 2"
            "196 Column: 1 The function \"recarga_2_3/target_stayon_CreateFcn"
            "\" was called with more than the declared number of inputs (3)."),
          NULL);
    }
    for (i = 0; i < 3 && i < nrhs; ++i) {
        mprhs[i] = prhs[i];
    }
    for (; i < 3; ++i) {
        mprhs[i] = NULL;
    }
    mlfEnterNewContext(0, 3, mprhs[0], mprhs[1], mprhs[2]);
    Mrecarga_2_3_target_stayon_CreateFcn(mprhs[0], mprhs[1], mprhs[2]);
    mlfRestorePreviousContext(0, 3, mprhs[0], mprhs[1], mprhs[2]);
}

/*
 * The function "mlfRecarga_2_3_target_stayon_Callback" contains the normal
 * interface for the "recarga_2_3/target_stayon_Callback" M-function from file
 * "u:\final_recarga6\recarga\recarga_2_3.m" (lines 2211-2221). This function
 * processes any input arguments and passes them to the implementation version
 * of the function, appearing above.
 */
static void mlfRecarga_2_3_target_stayon_Callback(mxArray * hObject,
                                                  mxArray * eventdata,
                                                  mxArray * handles) {
    mlfEnterNewContext(0, 3, hObject, eventdata, handles);
    Mrecarga_2_3_target_stayon_Callback(hObject, eventdata, handles);
    mlfRestorePreviousContext(0, 3, hObject, eventdata, handles);
}

/*
 * The function "mlxRecarga_2_3_target_stayon_Callback" contains the feval
 * interface for the "recarga_2_3/target_stayon_Callback" M-function from file
 * "u:\final_recarga6\recarga\recarga_2_3.m" (lines 2211-2221). The feval
 * function calls the implementation version of
 * recarga_2_3/target_stayon_Callback through this function. This function
 * processes any input arguments and passes them to the implementation version
 * of the function, appearing above.
 */
static void mlxRecarga_2_3_target_stayon_Callback(int nlhs,
                                                  mxArray * plhs[],
                                                  int nrhs,
                                                  mxArray * prhs[]) {
    mxArray * mprhs[3];
    int i;
    if (nlhs > 0) {
        mlfError(
          mxCreateString(
            "Run-time Error: File: recarga_2_3/target_stayon_Callback Line: 22"
            "11 Column: 1 The function \"recarga_2_3/target_stayon_Callback\" "
            "was called with more than the declared number of outputs (0)."),
          NULL);
    }
    if (nrhs > 3) {
        mlfError(
          mxCreateString(
            "Run-time Error: File: recarga_2_3/target_stayon_Callback Line: 22"
            "11 Column: 1 The function \"recarga_2_3/target_stayon_Callback\" "
            "was called with more than the declared number of inputs (3)."),
          NULL);
    }
    for (i = 0; i < 3 && i < nrhs; ++i) {
        mprhs[i] = prhs[i];
    }
    for (; i < 3; ++i) {
        mprhs[i] = NULL;
    }
    mlfEnterNewContext(0, 3, mprhs[0], mprhs[1], mprhs[2]);
    Mrecarga_2_3_target_stayon_Callback(mprhs[0], mprhs[1], mprhs[2]);
    mlfRestorePreviousContext(0, 3, mprhs[0], mprhs[1], mprhs[2]);
}

/*
 * The function "mlfRecarga_2_3_Estimate_FAR_CreateFcn" contains the normal
 * interface for the "recarga_2_3/Estimate_FAR_CreateFcn" M-function from file
 * "u:\final_recarga6\recarga\recarga_2_3.m" (lines 2221-2236). This function
 * processes any input arguments and passes them to the implementation version
 * of the function, appearing above.
 */
static void mlfRecarga_2_3_Estimate_FAR_CreateFcn(mxArray * hObject,
                                                  mxArray * eventdata,
                                                  mxArray * handles) {
    mlfEnterNewContext(0, 3, hObject, eventdata, handles);
    Mrecarga_2_3_Estimate_FAR_CreateFcn(hObject, eventdata, handles);
    mlfRestorePreviousContext(0, 3, hObject, eventdata, handles);
}

/*
 * The function "mlxRecarga_2_3_Estimate_FAR_CreateFcn" contains the feval
 * interface for the "recarga_2_3/Estimate_FAR_CreateFcn" M-function from file
 * "u:\final_recarga6\recarga\recarga_2_3.m" (lines 2221-2236). The feval
 * function calls the implementation version of
 * recarga_2_3/Estimate_FAR_CreateFcn through this function. This function
 * processes any input arguments and passes them to the implementation version
 * of the function, appearing above.
 */
static void mlxRecarga_2_3_Estimate_FAR_CreateFcn(int nlhs,
                                                  mxArray * plhs[],
                                                  int nrhs,
                                                  mxArray * prhs[]) {
    mxArray * mprhs[3];
    int i;
    if (nlhs > 0) {
        mlfError(
          mxCreateString(
            "Run-time Error: File: recarga_2_3/Estimate_FAR_CreateFcn Line: 22"
            "21 Column: 1 The function \"recarga_2_3/Estimate_FAR_CreateFcn\" "
            "was called with more than the declared number of outputs (0)."),
          NULL);
    }
    if (nrhs > 3) {
        mlfError(
          mxCreateString(
            "Run-time Error: File: recarga_2_3/Estimate_FAR_CreateFcn Line: 22"
            "21 Column: 1 The function \"recarga_2_3/Estimate_FAR_CreateFcn\" "
            "was called with more than the declared number of inputs (3)."),
          NULL);
    }
    for (i = 0; i < 3 && i < nrhs; ++i) {
        mprhs[i] = prhs[i];
    }
    for (; i < 3; ++i) {
        mprhs[i] = NULL;
    }
    mlfEnterNewContext(0, 3, mprhs[0], mprhs[1], mprhs[2]);
    Mrecarga_2_3_Estimate_FAR_CreateFcn(mprhs[0], mprhs[1], mprhs[2]);
    mlfRestorePreviousContext(0, 3, mprhs[0], mprhs[1], mprhs[2]);
}

/*
 * The function "mlfRecarga_2_3_Estimate_FAR_Callback" contains the normal
 * interface for the "recarga_2_3/Estimate_FAR_Callback" M-function from file
 * "u:\final_recarga6\recarga\recarga_2_3.m" (lines 2236-2246). This function
 * processes any input arguments and passes them to the implementation version
 * of the function, appearing above.
 */
static void mlfRecarga_2_3_Estimate_FAR_Callback(mxArray * hObject,
                                                 mxArray * eventdata,
                                                 mxArray * handles) {
    mlfEnterNewContext(0, 3, hObject, eventdata, handles);
    Mrecarga_2_3_Estimate_FAR_Callback(hObject, eventdata, handles);
    mlfRestorePreviousContext(0, 3, hObject, eventdata, handles);
}

/*
 * The function "mlxRecarga_2_3_Estimate_FAR_Callback" contains the feval
 * interface for the "recarga_2_3/Estimate_FAR_Callback" M-function from file
 * "u:\final_recarga6\recarga\recarga_2_3.m" (lines 2236-2246). The feval
 * function calls the implementation version of
 * recarga_2_3/Estimate_FAR_Callback through this function. This function
 * processes any input arguments and passes them to the implementation version
 * of the function, appearing above.
 */
static void mlxRecarga_2_3_Estimate_FAR_Callback(int nlhs,
                                                 mxArray * plhs[],
                                                 int nrhs,
                                                 mxArray * prhs[]) {
    mxArray * mprhs[3];
    int i;
    if (nlhs > 0) {
        mlfError(
          mxCreateString(
            "Run-time Error: File: recarga_2_3/Estimate_FAR_Callback Line: 22"
            "36 Column: 1 The function \"recarga_2_3/Estimate_FAR_Callback\" "
            "was called with more than the declared number of outputs (0)."),
          NULL);
    }
    if (nrhs > 3) {
        mlfError(
          mxCreateString(
            "Run-time Error: File: recarga_2_3/Estimate_FAR_Callback Line: 22"
            "36 Column: 1 The function \"recarga_2_3/Estimate_FAR_Callback\" "
            "was called with more than the declared number of inputs (3)."),
          NULL);
    }
    for (i = 0; i < 3 && i < nrhs; ++i) {
        mprhs[i] = prhs[i];
    }
    for (; i < 3; ++i) {
        mprhs[i] = NULL;
    }
    mlfEnterNewContext(0, 3, mprhs[0], mprhs[1], mprhs[2]);
    Mrecarga_2_3_Estimate_FAR_Callback(mprhs[0], mprhs[1], mprhs[2]);
    mlfRestorePreviousContext(0, 3, mprhs[0], mprhs[1], mprhs[2]);
}

/*
 * The function "mlfRecarga_2_3_axes5_CreateFcn" contains the normal interface
 * for the "recarga_2_3/axes5_CreateFcn" M-function from file
 * "u:\final_recarga6\recarga\recarga_2_3.m" (lines 2246-2255). This function
 * processes any input arguments and passes them to the implementation version
 * of the function, appearing above.
 */
static void mlfRecarga_2_3_axes5_CreateFcn(mxArray * hObject,
                                           mxArray * eventdata,
                                           mxArray * handles) {
    mlfEnterNewContext(0, 3, hObject, eventdata, handles);
    Mrecarga_2_3_axes5_CreateFcn(hObject, eventdata, handles);
    mlfRestorePreviousContext(0, 3, hObject, eventdata, handles);
}

/*
 * The function "mlxRecarga_2_3_axes5_CreateFcn" contains the feval interface
 * for the "recarga_2_3/axes5_CreateFcn" M-function from file
 * "u:\final_recarga6\recarga\recarga_2_3.m" (lines 2246-2255). The feval
 * function calls the implementation version of recarga_2_3/axes5_CreateFcn
 * through this function. This function processes any input arguments and
 * passes them to the implementation version of the function, appearing above.
 */
static void mlxRecarga_2_3_axes5_CreateFcn(int nlhs,
                                           mxArray * plhs[],
                                           int nrhs,
                                           mxArray * prhs[]) {
    mxArray * mprhs[3];
    int i;
    if (nlhs > 0) {
        mlfError(
          mxCreateString(
            "Run-time Error: File: recarga_2_3/axes5_CreateFcn Line: 2246"
            " Column: 1 The function \"recarga_2_3/axes5_CreateFcn\" was "
            "called with more than the declared number of outputs (0)."),
          NULL);
    }
    if (nrhs > 3) {
        mlfError(
          mxCreateString(
            "Run-time Error: File: recarga_2_3/axes5_CreateFcn Line: 2246"
            " Column: 1 The function \"recarga_2_3/axes5_CreateFcn\" was "
            "called with more than the declared number of inputs (3)."),
          NULL);
    }
    for (i = 0; i < 3 && i < nrhs; ++i) {
        mprhs[i] = prhs[i];
    }
    for (; i < 3; ++i) {
        mprhs[i] = NULL;
    }
    mlfEnterNewContext(0, 3, mprhs[0], mprhs[1], mprhs[2]);
    Mrecarga_2_3_axes5_CreateFcn(mprhs[0], mprhs[1], mprhs[2]);
    mlfRestorePreviousContext(0, 3, mprhs[0], mprhs[1], mprhs[2]);
}

/*
 * The function "mlfRecarga_2_3_axes9_CreateFcn" contains the normal interface
 * for the "recarga_2_3/axes9_CreateFcn" M-function from file
 * "u:\final_recarga6\recarga\recarga_2_3.m" (lines 2255-2263). This function
 * processes any input arguments and passes them to the implementation version
 * of the function, appearing above.
 */
static void mlfRecarga_2_3_axes9_CreateFcn(mxArray * hObject,
                                           mxArray * eventdata,
                                           mxArray * handles) {
    mlfEnterNewContext(0, 3, hObject, eventdata, handles);
    Mrecarga_2_3_axes9_CreateFcn(hObject, eventdata, handles);
    mlfRestorePreviousContext(0, 3, hObject, eventdata, handles);
}

/*
 * The function "mlxRecarga_2_3_axes9_CreateFcn" contains the feval interface
 * for the "recarga_2_3/axes9_CreateFcn" M-function from file
 * "u:\final_recarga6\recarga\recarga_2_3.m" (lines 2255-2263). The feval
 * function calls the implementation version of recarga_2_3/axes9_CreateFcn
 * through this function. This function processes any input arguments and
 * passes them to the implementation version of the function, appearing above.
 */
static void mlxRecarga_2_3_axes9_CreateFcn(int nlhs,
                                           mxArray * plhs[],
                                           int nrhs,
                                           mxArray * prhs[]) {
    mxArray * mprhs[3];
    int i;
    if (nlhs > 0) {
        mlfError(
          mxCreateString(
            "Run-time Error: File: recarga_2_3/axes9_CreateFcn Line: 2255"
            " Column: 1 The function \"recarga_2_3/axes9_CreateFcn\" was "
            "called with more than the declared number of outputs (0)."),
          NULL);
    }
    if (nrhs > 3) {
        mlfError(
          mxCreateString(
            "Run-time Error: File: recarga_2_3/axes9_CreateFcn Line: 2255"
            " Column: 1 The function \"recarga_2_3/axes9_CreateFcn\" was "
            "called with more than the declared number of inputs (3)."),
          NULL);
    }
    for (i = 0; i < 3 && i < nrhs; ++i) {
        mprhs[i] = prhs[i];
    }
    for (; i < 3; ++i) {
        mprhs[i] = NULL;
    }
    mlfEnterNewContext(0, 3, mprhs[0], mprhs[1], mprhs[2]);
    Mrecarga_2_3_axes9_CreateFcn(mprhs[0], mprhs[1], mprhs[2]);
    mlfRestorePreviousContext(0, 3, mprhs[0], mprhs[1], mprhs[2]);
}

/*
 * The function "Mrecarga_2_3" is the implementation version of the
 * "recarga_2_3" M-function from file "u:\final_recarga6\recarga\recarga_2_3.m"
 * (lines 1-48). It contains the actual compiled code for that M-function. It
 * is a static function and must only be called from one of the interface
 * functions, appearing below.
 */
/*
 * function varargout = RECARGA_2_3(varargin)
 */
static mxArray * Mrecarga_2_3(int nargout_, mxArray * varargin) {
    mexLocalFunctionTable save_local_function_table_
      = mclSetCurrentLocalFunctionTable(&_local_function_table_recarga_2_3);
    int nargin_ = mclNargin(-1, varargin, NULL);
    mxArray * varargout = NULL;
    mxArray * ans = NULL;
    mxArray * _T0_ = NULL;
    mxArray * gui_State = NULL;
    mxArray * gui_Singleton = NULL;
    mclCopyArray(&varargin);
    /*
     * % RECARGA_2_3 M-file for RECARGA_2_3.fig
     * %      RECARGA_2_3, by itself, creates a new RECARGA_2_3 or raises the existing
     * %      singleton*.
     * %
     * %      H = RECARGA_2_3 returns the handle to a new RECARGA_2_3 or the handle to
     * %      the existing singleton*.
     * %
     * %      RECARGA_2_3('CALLBACK',hObject,eventData,handles,...) calls the local
     * %      function named CALLBACK in RECARGA_2_3.M with the given input arguments.
     * %
     * %      RECARGA_2_3('Property','Value',...) creates a new RECARGA_2_3 or raises the
     * %      existing singleton*.  Starting from the left, property value pairs are
     * %      applied to the GUI before RECARGA_2_3_OpeningFunction gets called.  An
     * %      unrecognized property input or invalid value makes property application
     * %      stop.  All inputs are passed to RECARGA_2_3_OpeningFcn via varargin.
     * %
     * %      *See GUI Options on GUIDE's Tools menu.  Choose "GUI allows only one
     * %      instance to run (singleton)".
     * %
     * % See also: GUIDE, GUIDATA, GUIHANDLES
     * 
     * % Edit the above text to modify the response to help RECARGA_2_3
     * 
     * % Last Modified by GUIDE v2.5 19-Aug-2004 13:28:53
     * 
     * % Begin initialization code - DO NOT EDIT
     * gui_Singleton = 1;
     */
    mlfAssign(&gui_Singleton, _mxarray0_);
    /*
     * gui_State = struct('gui_Name',       mfilename, ...
     */
    mlfAssign(
      &gui_State,
      mlfStruct(
        _mxarray1_,
        mxCreateString("recarga_2_3"),
        _mxarray3_,
        mclVv(gui_Singleton, "gui_Singleton"),
        _mxarray5_,
        mclCreateSimpleFunctionHandle(
          mlxRecarga_2_3_RECARGA_2_3_OpeningFcn, "RECARGA_2_3_OpeningFcn"),
        _mxarray7_,
        mclCreateSimpleFunctionHandle(
          mlxRecarga_2_3_RECARGA_2_3_OutputFcn, "RECARGA_2_3_OutputFcn"),
        _mxarray9_,
        _mxarray11_,
        _mxarray12_,
        _mxarray11_,
        NULL));
    /*
     * 'gui_Singleton',  gui_Singleton, ...
     * 'gui_OpeningFcn', @RECARGA_2_3_OpeningFcn, ...
     * 'gui_OutputFcn',  @RECARGA_2_3_OutputFcn, ...
     * 'gui_LayoutFcn',  [] , ...
     * 'gui_Callback',   []);
     * if nargin & isstr(varargin{1})
     */
    {
        mxArray * a_ = mclInitialize(mlfScalar(nargin_));
        if (mlfTobool(a_)
            && mlfTobool(
                 mclAnd(
                   a_,
                   mclFeval(
                     mclValueVarargout(),
                     mlxIsstr,
                     mlfIndexRef(
                       mclVa(varargin, "varargin"), "{?}", _mxarray0_),
                     NULL)))) {
            mxDestroyArray(a_);
            /*
             * gui_State.gui_Callback = str2func(varargin{1});
             */
            mlfIndexAssign(
              &gui_State,
              ".gui_Callback",
              mclFeval(
                mclValueVarargout(),
                mlxStr2func,
                mlfIndexRef(mclVa(varargin, "varargin"), "{?}", _mxarray0_),
                NULL));
        } else {
            mxDestroyArray(a_);
        }
    /*
     * end
     */
    }
    /*
     * 
     * if nargout
     */
    if (nargout_ != 0) {
        mlfAssign(&_T0_, mlfColon(_mxarray0_, mlfScalar(nargout_), NULL));
        /*
         * [varargout{1:nargout}] = gui_mainfcn(gui_State, varargin{:});
         */
        mlfNGui_mainfcn(
          0,
          mlfIndexVarargout(&varargout, "{?}", _T0_, NULL),
          mclVv(gui_State, "gui_State"),
          mlfIndexRef(
            mclVa(varargin, "varargin"), "{?}", mlfCreateColonIndex()),
          NULL);
    /*
     * else
     */
    } else {
        /*
         * gui_mainfcn(gui_State, varargin{:});
         */
        mclAssignAns(
          &ans,
          mlfNGui_mainfcn(
            0,
            mclAnsVarargout(),
            mclVv(gui_State, "gui_State"),
            mlfIndexRef(
              mclVa(varargin, "varargin"), "{?}", mlfCreateColonIndex()),
            NULL));
    /*
     * end
     */
    }
    mxDestroyArray(gui_Singleton);
    mxDestroyArray(gui_State);
    mxDestroyArray(_T0_);
    mxDestroyArray(ans);
    mxDestroyArray(varargin);
    mclSetCurrentLocalFunctionTable(save_local_function_table_);
    return varargout;
    /*
     * % End initialization code - DO NOT EDIT
     * 
     * 
     * % --- Executes just before RECARGA_2_3 is made visible.
     */
}

/*
 * The function "Mrecarga_2_3_RECARGA_2_3_OpeningFcn" is the implementation
 * version of the "recarga_2_3/RECARGA_2_3_OpeningFcn" M-function from file
 * "u:\final_recarga6\recarga\recarga_2_3.m" (lines 48-83). It contains the
 * actual compiled code for that M-function. It is a static function and must
 * only be called from one of the interface functions, appearing below.
 */
/*
 * function RECARGA_2_3_OpeningFcn(hObject, eventdata, handles, varargin)
 */
static void Mrecarga_2_3_RECARGA_2_3_OpeningFcn(mxArray * hObject,
                                                mxArray * eventdata,
                                                mxArray * handles,
                                                mxArray * varargin) {
    mexLocalFunctionTable save_local_function_table_
      = mclSetCurrentLocalFunctionTable(&_local_function_table_recarga_2_3);
    mxArray * position = NULL;
    mxArray * info = NULL;
    mxArray * prevunit = NULL;
    mxArray * ans = NULL;
    mclCopyArray(&hObject);
    mclCopyArray(&eventdata);
    mclCopyArray(&handles);
    mclCopyArray(&varargin);
    /*
     * % This function has no output args, see OutputFcn.
     * % hObject    handle to figure
     * % eventdata  reserved - to be defined in a future version of MATLAB
     * % handles    structure with handles and user data (see GUIDATA)
     * % varargin   command line arguments to RECARGA_2_3 (see VARARGIN)
     * 
     * % Choose default command line output for RECARGA_2_3
     * handles.output = hObject;
     */
    mlfIndexAssign(&handles, ".output", mclVa(hObject, "hObject"));
    /*
     * 
     * % Update handles structure
     * guidata(hObject, handles);
     */
    mclAssignAns(
      &ans,
      mlfNGuidata(0, mclVa(hObject, "hObject"), mclVa(handles, "handles")));
    /*
     * 
     * prevunit=1;
     */
    mlfAssign(&prevunit, _mxarray0_);
    /*
     * 
     * % Image Files Code
     * set(hObject, 'Units', 'normalized');
     */
    mclAssignAns(
      &ans,
      mlfNSet(0, mclVa(hObject, "hObject"), _mxarray14_, _mxarray16_, NULL));
    /*
     * handles.RGpic = imread([filesep 'RG.jpg']); % Read the image file RGpic.jpg
     */
    mlfIndexAssign(
      &handles,
      ".RGpic",
      mlfNImread(
        1, NULL, NULL, mlfHorzcat(mlfFilesep(), _mxarray18_, NULL), NULL));
    /*
     * info = imfinfo([filesep 'RG.jpg']); % Determine the size of the image file
     */
    mlfAssign(
      &info,
      mlfNImfinfo(1, NULL, mlfHorzcat(mlfFilesep(), _mxarray18_, NULL), NULL));
    /*
     * position = get(hObject, 'Position');
     */
    mlfAssign(
      &position, mlfNGet(1, mclVa(hObject, "hObject"), _mxarray20_, NULL));
    /*
     * axes(handles.ICON);
     */
    mclAssignAns(
      &ans, mlfNAxes(0, mlfIndexRef(mclVa(handles, "handles"), ".ICON"), NULL));
    /*
     * image(handles.RGpic)
     */
    mclPrintAns(
      &ans,
      mlfNImage(0, mlfIndexRef(mclVa(handles, "handles"), ".RGpic"), NULL));
    /*
     * set(handles.ICON,'Visible', 'off');
     */
    mclAssignAns(
      &ans,
      mlfNSet(
        0,
        mlfIndexRef(mclVa(handles, "handles"), ".ICON"),
        _mxarray22_,
        _mxarray24_,
        NULL));
    /*
     * 
     * handles.RGprof = imread([filesep 'RGProf.jpg']); % Read the image file RGpic.jpg
     */
    mlfIndexAssign(
      &handles,
      ".RGprof",
      mlfNImread(
        1, NULL, NULL, mlfHorzcat(mlfFilesep(), _mxarray26_, NULL), NULL));
    /*
     * info = imfinfo([filesep 'RGProf.jpg']); % Determine the size of the image file
     */
    mlfAssign(
      &info,
      mlfNImfinfo(1, NULL, mlfHorzcat(mlfFilesep(), _mxarray26_, NULL), NULL));
    /*
     * position = get(hObject, 'Position');
     */
    mlfAssign(
      &position, mlfNGet(1, mclVa(hObject, "hObject"), _mxarray20_, NULL));
    /*
     * axes(handles.Profile);
     */
    mclAssignAns(
      &ans,
      mlfNAxes(0, mlfIndexRef(mclVa(handles, "handles"), ".Profile"), NULL));
    /*
     * image(handles.RGprof)
     */
    mclPrintAns(
      &ans,
      mlfNImage(0, mlfIndexRef(mclVa(handles, "handles"), ".RGprof"), NULL));
    /*
     * set(handles.Profile,'Visible', 'off');
     */
    mclAssignAns(
      &ans,
      mlfNSet(
        0,
        mlfIndexRef(mclVa(handles, "handles"), ".Profile"),
        _mxarray22_,
        _mxarray24_,
        NULL));
    mxDestroyArray(ans);
    mxDestroyArray(prevunit);
    mxDestroyArray(info);
    mxDestroyArray(position);
    mxDestroyArray(varargin);
    mxDestroyArray(handles);
    mxDestroyArray(eventdata);
    mxDestroyArray(hObject);
    mclSetCurrentLocalFunctionTable(save_local_function_table_);
    /*
     * % UIWAIT makes RECARGA_2_3 wait for user response (see UIRESUME)
     * % uiwait(handles.figure1);
     * 
     * 
     * % --- Outputs from this function are returned to the command line.
     */
}

/*
 * The function "Mrecarga_2_3_RECARGA_2_3_OutputFcn" is the implementation
 * version of the "recarga_2_3/RECARGA_2_3_OutputFcn" M-function from file
 * "u:\final_recarga6\recarga\recarga_2_3.m" (lines 83-92). It contains the
 * actual compiled code for that M-function. It is a static function and must
 * only be called from one of the interface functions, appearing below.
 */
/*
 * function varargout = RECARGA_2_3_OutputFcn(hObject, eventdata, handles)
 */
static mxArray * Mrecarga_2_3_RECARGA_2_3_OutputFcn(int nargout_,
                                                    mxArray * hObject,
                                                    mxArray * eventdata,
                                                    mxArray * handles) {
    mexLocalFunctionTable save_local_function_table_
      = mclSetCurrentLocalFunctionTable(&_local_function_table_recarga_2_3);
    mxArray * varargout = NULL;
    mclCopyArray(&hObject);
    mclCopyArray(&eventdata);
    mclCopyArray(&handles);
    /*
     * % varargout  cell array for returning output args (see VARARGOUT);
     * % hObject    handle to figure
     * % eventdata  reserved - to be defined in a future version of MATLAB
     * % handles    structure with handles and user data (see GUIDATA)
     * 
     * % Get default command line output from handles structure
     * varargout{1} = handles.output;
     */
    mlfIndexAssign(
      &varargout,
      "{?}",
      _mxarray0_,
      mlfIndexRef(mclVa(handles, "handles"), ".output"));
    mxDestroyArray(handles);
    mxDestroyArray(eventdata);
    mxDestroyArray(hObject);
    mclSetCurrentLocalFunctionTable(save_local_function_table_);
    return varargout;
    /*
     * 
     */
}

/*
 * The function "Mrecarga_2_3_Process_Callback" is the implementation version
 * of the "recarga_2_3/Process_Callback" M-function from file
 * "u:\final_recarga6\recarga\recarga_2_3.m" (lines 92-102). It contains the
 * actual compiled code for that M-function. It is a static function and must
 * only be called from one of the interface functions, appearing below.
 */
/*
 * function Process_Callback(hObject, eventdata, handles)
 */
static void Mrecarga_2_3_Process_Callback(mxArray * hObject,
                                          mxArray * eventdata,
                                          mxArray * handles) {
    mexLocalFunctionTable save_local_function_table_
      = mclSetCurrentLocalFunctionTable(&_local_function_table_recarga_2_3);
    mclCopyArray(&hObject);
    mclCopyArray(&eventdata);
    mclCopyArray(&handles);
    mxDestroyArray(handles);
    mxDestroyArray(eventdata);
    mxDestroyArray(hObject);
    mclSetCurrentLocalFunctionTable(save_local_function_table_);
    /*
     * % hObject    handle to Process (see GCBO)
     * % eventdata  reserved - to be defined in a future version of MATLAB
     * % handles    structure with handles and user data (see GUIDATA)
     * 
     * % Hints: get(hObject,'String') returns contents of Process as text
     * %        str2double(get(hObject,'String')) returns contents of Process as a double
     * 
     * 
     * % --- Executes during object creation, after setting all properties.
     */
}

/*
 * The function "Mrecarga_2_3_Progress_CreateFcn" is the implementation version
 * of the "recarga_2_3/Progress_CreateFcn" M-function from file
 * "u:\final_recarga6\recarga\recarga_2_3.m" (lines 102-117). It contains the
 * actual compiled code for that M-function. It is a static function and must
 * only be called from one of the interface functions, appearing below.
 */
/*
 * function Progress_CreateFcn(hObject, eventdata, handles)
 */
static void Mrecarga_2_3_Progress_CreateFcn(mxArray * hObject,
                                            mxArray * eventdata,
                                            mxArray * handles) {
    mexLocalFunctionTable save_local_function_table_
      = mclSetCurrentLocalFunctionTable(&_local_function_table_recarga_2_3);
    mxArray * ans = NULL;
    mclCopyArray(&hObject);
    mclCopyArray(&eventdata);
    mclCopyArray(&handles);
    /*
     * % hObject    handle to Progress (see GCBO)
     * % eventdata  reserved - to be defined in a future version of MATLAB
     * % handles    empty - handles not created until after all CreateFcns called
     * 
     * % Hint: edit controls usually have a white background on Windows.
     * %       See ISPC and COMPUTER.
     * if ispc
     */
    if (mlfTobool(mlfIspc())) {
        /*
         * set(hObject,'BackgroundColor','white');
         */
        mclAssignAns(
          &ans,
          mlfNSet(
            0, mclVa(hObject, "hObject"), _mxarray28_, _mxarray30_, NULL));
    /*
     * else
     */
    } else {
        /*
         * set(hObject,'BackgroundColor',get(0,'defaultUicontrolBackgroundColor'));
         */
        mclAssignAns(
          &ans,
          mlfNSet(
            0,
            mclVa(hObject, "hObject"),
            _mxarray28_,
            mlfNGet(1, _mxarray32_, _mxarray33_, NULL),
            NULL));
    /*
     * end
     */
    }
    mxDestroyArray(ans);
    mxDestroyArray(handles);
    mxDestroyArray(eventdata);
    mxDestroyArray(hObject);
    mclSetCurrentLocalFunctionTable(save_local_function_table_);
    /*
     * 
     * 
     * 
     */
}

/*
 * The function "Mrecarga_2_3_Progress_Callback" is the implementation version
 * of the "recarga_2_3/Progress_Callback" M-function from file
 * "u:\final_recarga6\recarga\recarga_2_3.m" (lines 117-127). It contains the
 * actual compiled code for that M-function. It is a static function and must
 * only be called from one of the interface functions, appearing below.
 */
/*
 * function Progress_Callback(hObject, eventdata, handles)
 */
static void Mrecarga_2_3_Progress_Callback(mxArray * hObject,
                                           mxArray * eventdata,
                                           mxArray * handles) {
    mexLocalFunctionTable save_local_function_table_
      = mclSetCurrentLocalFunctionTable(&_local_function_table_recarga_2_3);
    mclCopyArray(&hObject);
    mclCopyArray(&eventdata);
    mclCopyArray(&handles);
    mxDestroyArray(handles);
    mxDestroyArray(eventdata);
    mxDestroyArray(hObject);
    mclSetCurrentLocalFunctionTable(save_local_function_table_);
    /*
     * % hObject    handle to Progress (see GCBO)
     * % eventdata  reserved - to be defined in a future version of MATLAB
     * % handles    structure with handles and user data (see GUIDATA)
     * 
     * % Hints: get(hObject,'String') returns contents of Progress as text
     * %        str2double(get(hObject,'String')) returns contents of Progress as a double
     * 
     * 
     * % --- Executes during object creation, after setting all properties.
     */
}

/*
 * The function "Mrecarga_2_3_Runon_CreateFcn" is the implementation version of
 * the "recarga_2_3/Runon_CreateFcn" M-function from file
 * "u:\final_recarga6\recarga\recarga_2_3.m" (lines 127-142). It contains the
 * actual compiled code for that M-function. It is a static function and must
 * only be called from one of the interface functions, appearing below.
 */
/*
 * function Runon_CreateFcn(hObject, eventdata, handles)
 */
static void Mrecarga_2_3_Runon_CreateFcn(mxArray * hObject,
                                         mxArray * eventdata,
                                         mxArray * handles) {
    mexLocalFunctionTable save_local_function_table_
      = mclSetCurrentLocalFunctionTable(&_local_function_table_recarga_2_3);
    mxArray * ans = NULL;
    mclCopyArray(&hObject);
    mclCopyArray(&eventdata);
    mclCopyArray(&handles);
    /*
     * % hObject    handle to Runon (see GCBO)
     * % eventdata  reserved - to be defined in a future version of MATLAB
     * % handles    empty - handles not created until after all CreateFcns called
     * 
     * % Hint: edit controls usually have a white background on Windows.
     * %       See ISPC and COMPUTER.
     * if ispc
     */
    if (mlfTobool(mlfIspc())) {
        /*
         * set(hObject,'BackgroundColor','white');
         */
        mclAssignAns(
          &ans,
          mlfNSet(
            0, mclVa(hObject, "hObject"), _mxarray28_, _mxarray30_, NULL));
    /*
     * else
     */
    } else {
        /*
         * set(hObject,'BackgroundColor',get(0,'defaultUicontrolBackgroundColor'));
         */
        mclAssignAns(
          &ans,
          mlfNSet(
            0,
            mclVa(hObject, "hObject"),
            _mxarray28_,
            mlfNGet(1, _mxarray32_, _mxarray33_, NULL),
            NULL));
    /*
     * end
     */
    }
    mxDestroyArray(ans);
    mxDestroyArray(handles);
    mxDestroyArray(eventdata);
    mxDestroyArray(hObject);
    mclSetCurrentLocalFunctionTable(save_local_function_table_);
    /*
     * 
     * 
     * 
     */
}

/*
 * The function "Mrecarga_2_3_Runon_Callback" is the implementation version of
 * the "recarga_2_3/Runon_Callback" M-function from file
 * "u:\final_recarga6\recarga\recarga_2_3.m" (lines 142-152). It contains the
 * actual compiled code for that M-function. It is a static function and must
 * only be called from one of the interface functions, appearing below.
 */
/*
 * function Runon_Callback(hObject, eventdata, handles)
 */
static void Mrecarga_2_3_Runon_Callback(mxArray * hObject,
                                        mxArray * eventdata,
                                        mxArray * handles) {
    mexLocalFunctionTable save_local_function_table_
      = mclSetCurrentLocalFunctionTable(&_local_function_table_recarga_2_3);
    mclCopyArray(&hObject);
    mclCopyArray(&eventdata);
    mclCopyArray(&handles);
    mxDestroyArray(handles);
    mxDestroyArray(eventdata);
    mxDestroyArray(hObject);
    mclSetCurrentLocalFunctionTable(save_local_function_table_);
    /*
     * % hObject    handle to Runon (see GCBO)
     * % eventdata  reserved - to be defined in a future version of MATLAB
     * % handles    structure with handles and user data (see GUIDATA)
     * 
     * % Hints: get(hObject,'String') returns contents of Runon as text
     * %        str2double(get(hObject,'String')) returns contents of Runon as a double
     * 
     * 
     * % --- Executes during object creation, after setting all properties.
     */
}

/*
 * The function "Mrecarga_2_3_Runoff_CreateFcn" is the implementation version
 * of the "recarga_2_3/Runoff_CreateFcn" M-function from file
 * "u:\final_recarga6\recarga\recarga_2_3.m" (lines 152-167). It contains the
 * actual compiled code for that M-function. It is a static function and must
 * only be called from one of the interface functions, appearing below.
 */
/*
 * function Runoff_CreateFcn(hObject, eventdata, handles)
 */
static void Mrecarga_2_3_Runoff_CreateFcn(mxArray * hObject,
                                          mxArray * eventdata,
                                          mxArray * handles) {
    mexLocalFunctionTable save_local_function_table_
      = mclSetCurrentLocalFunctionTable(&_local_function_table_recarga_2_3);
    mxArray * ans = NULL;
    mclCopyArray(&hObject);
    mclCopyArray(&eventdata);
    mclCopyArray(&handles);
    /*
     * % hObject    handle to Runoff (see GCBO)
     * % eventdata  reserved - to be defined in a future version of MATLAB
     * % handles    empty - handles not created until after all CreateFcns called
     * 
     * % Hint: edit controls usually have a white background on Windows.
     * %       See ISPC and COMPUTER.
     * if ispc
     */
    if (mlfTobool(mlfIspc())) {
        /*
         * set(hObject,'BackgroundColor','white');
         */
        mclAssignAns(
          &ans,
          mlfNSet(
            0, mclVa(hObject, "hObject"), _mxarray28_, _mxarray30_, NULL));
    /*
     * else
     */
    } else {
        /*
         * set(hObject,'BackgroundColor',get(0,'defaultUicontrolBackgroundColor'));
         */
        mclAssignAns(
          &ans,
          mlfNSet(
            0,
            mclVa(hObject, "hObject"),
            _mxarray28_,
            mlfNGet(1, _mxarray32_, _mxarray33_, NULL),
            NULL));
    /*
     * end
     */
    }
    mxDestroyArray(ans);
    mxDestroyArray(handles);
    mxDestroyArray(eventdata);
    mxDestroyArray(hObject);
    mclSetCurrentLocalFunctionTable(save_local_function_table_);
    /*
     * 
     * 
     * 
     */
}

/*
 * The function "Mrecarga_2_3_Runoff_Callback" is the implementation version of
 * the "recarga_2_3/Runoff_Callback" M-function from file
 * "u:\final_recarga6\recarga\recarga_2_3.m" (lines 167-177). It contains the
 * actual compiled code for that M-function. It is a static function and must
 * only be called from one of the interface functions, appearing below.
 */
/*
 * function Runoff_Callback(hObject, eventdata, handles)
 */
static void Mrecarga_2_3_Runoff_Callback(mxArray * hObject,
                                         mxArray * eventdata,
                                         mxArray * handles) {
    mexLocalFunctionTable save_local_function_table_
      = mclSetCurrentLocalFunctionTable(&_local_function_table_recarga_2_3);
    mclCopyArray(&hObject);
    mclCopyArray(&eventdata);
    mclCopyArray(&handles);
    mxDestroyArray(handles);
    mxDestroyArray(eventdata);
    mxDestroyArray(hObject);
    mclSetCurrentLocalFunctionTable(save_local_function_table_);
    /*
     * % hObject    handle to Runoff (see GCBO)
     * % eventdata  reserved - to be defined in a future version of MATLAB
     * % handles    structure with handles and user data (see GUIDATA)
     * 
     * % Hints: get(hObject,'String') returns contents of Runoff as text
     * %        str2double(get(hObject,'String')) returns contents of Runoff as a double
     * 
     * 
     * % --- Executes during object creation, after setting all properties.
     */
}

/*
 * The function "Mrecarga_2_3_Recharge_CreateFcn" is the implementation version
 * of the "recarga_2_3/Recharge_CreateFcn" M-function from file
 * "u:\final_recarga6\recarga\recarga_2_3.m" (lines 177-192). It contains the
 * actual compiled code for that M-function. It is a static function and must
 * only be called from one of the interface functions, appearing below.
 */
/*
 * function Recharge_CreateFcn(hObject, eventdata, handles)
 */
static void Mrecarga_2_3_Recharge_CreateFcn(mxArray * hObject,
                                            mxArray * eventdata,
                                            mxArray * handles) {
    mexLocalFunctionTable save_local_function_table_
      = mclSetCurrentLocalFunctionTable(&_local_function_table_recarga_2_3);
    mxArray * ans = NULL;
    mclCopyArray(&hObject);
    mclCopyArray(&eventdata);
    mclCopyArray(&handles);
    /*
     * % hObject    handle to Recharge (see GCBO)
     * % eventdata  reserved - to be defined in a future version of MATLAB
     * % handles    empty - handles not created until after all CreateFcns called
     * 
     * % Hint: edit controls usually have a white background on Windows.
     * %       See ISPC and COMPUTER.
     * if ispc
     */
    if (mlfTobool(mlfIspc())) {
        /*
         * set(hObject,'BackgroundColor','white');
         */
        mclAssignAns(
          &ans,
          mlfNSet(
            0, mclVa(hObject, "hObject"), _mxarray28_, _mxarray30_, NULL));
    /*
     * else
     */
    } else {
        /*
         * set(hObject,'BackgroundColor',get(0,'defaultUicontrolBackgroundColor'));
         */
        mclAssignAns(
          &ans,
          mlfNSet(
            0,
            mclVa(hObject, "hObject"),
            _mxarray28_,
            mlfNGet(1, _mxarray32_, _mxarray33_, NULL),
            NULL));
    /*
     * end
     */
    }
    mxDestroyArray(ans);
    mxDestroyArray(handles);
    mxDestroyArray(eventdata);
    mxDestroyArray(hObject);
    mclSetCurrentLocalFunctionTable(save_local_function_table_);
    /*
     * 
     * 
     * 
     */
}

/*
 * The function "Mrecarga_2_3_Recharge_Callback" is the implementation version
 * of the "recarga_2_3/Recharge_Callback" M-function from file
 * "u:\final_recarga6\recarga\recarga_2_3.m" (lines 192-202). It contains the
 * actual compiled code for that M-function. It is a static function and must
 * only be called from one of the interface functions, appearing below.
 */
/*
 * function Recharge_Callback(hObject, eventdata, handles)
 */
static void Mrecarga_2_3_Recharge_Callback(mxArray * hObject,
                                           mxArray * eventdata,
                                           mxArray * handles) {
    mexLocalFunctionTable save_local_function_table_
      = mclSetCurrentLocalFunctionTable(&_local_function_table_recarga_2_3);
    mclCopyArray(&hObject);
    mclCopyArray(&eventdata);
    mclCopyArray(&handles);
    mxDestroyArray(handles);
    mxDestroyArray(eventdata);
    mxDestroyArray(hObject);
    mclSetCurrentLocalFunctionTable(save_local_function_table_);
    /*
     * % hObject    handle to Recharge (see GCBO)
     * % eventdata  reserved - to be defined in a future version of MATLAB
     * % handles    structure with handles and user data (see GUIDATA)
     * 
     * % Hints: get(hObject,'String') returns contents of Recharge as text
     * %        str2double(get(hObject,'String')) returns contents of Recharge as a double
     * 
     * 
     * % --- Executes during object creation, after setting all properties.
     */
}

/*
 * The function "Mrecarga_2_3_Evap_CreateFcn" is the implementation version of
 * the "recarga_2_3/Evap_CreateFcn" M-function from file
 * "u:\final_recarga6\recarga\recarga_2_3.m" (lines 202-217). It contains the
 * actual compiled code for that M-function. It is a static function and must
 * only be called from one of the interface functions, appearing below.
 */
/*
 * function Evap_CreateFcn(hObject, eventdata, handles)
 */
static void Mrecarga_2_3_Evap_CreateFcn(mxArray * hObject,
                                        mxArray * eventdata,
                                        mxArray * handles) {
    mexLocalFunctionTable save_local_function_table_
      = mclSetCurrentLocalFunctionTable(&_local_function_table_recarga_2_3);
    mxArray * ans = NULL;
    mclCopyArray(&hObject);
    mclCopyArray(&eventdata);
    mclCopyArray(&handles);
    /*
     * % hObject    handle to Evap (see GCBO)
     * % eventdata  reserved - to be defined in a future version of MATLAB
     * % handles    empty - handles not created until after all CreateFcns called
     * 
     * % Hint: edit controls usually have a white background on Windows.
     * %       See ISPC and COMPUTER.
     * if ispc
     */
    if (mlfTobool(mlfIspc())) {
        /*
         * set(hObject,'BackgroundColor','white');
         */
        mclAssignAns(
          &ans,
          mlfNSet(
            0, mclVa(hObject, "hObject"), _mxarray28_, _mxarray30_, NULL));
    /*
     * else
     */
    } else {
        /*
         * set(hObject,'BackgroundColor',get(0,'defaultUicontrolBackgroundColor'));
         */
        mclAssignAns(
          &ans,
          mlfNSet(
            0,
            mclVa(hObject, "hObject"),
            _mxarray28_,
            mlfNGet(1, _mxarray32_, _mxarray33_, NULL),
            NULL));
    /*
     * end
     */
    }
    mxDestroyArray(ans);
    mxDestroyArray(handles);
    mxDestroyArray(eventdata);
    mxDestroyArray(hObject);
    mclSetCurrentLocalFunctionTable(save_local_function_table_);
    /*
     * 
     * 
     * 
     */
}

/*
 * The function "Mrecarga_2_3_Evap_Callback" is the implementation version of
 * the "recarga_2_3/Evap_Callback" M-function from file
 * "u:\final_recarga6\recarga\recarga_2_3.m" (lines 217-227). It contains the
 * actual compiled code for that M-function. It is a static function and must
 * only be called from one of the interface functions, appearing below.
 */
/*
 * function Evap_Callback(hObject, eventdata, handles)
 */
static void Mrecarga_2_3_Evap_Callback(mxArray * hObject,
                                       mxArray * eventdata,
                                       mxArray * handles) {
    mexLocalFunctionTable save_local_function_table_
      = mclSetCurrentLocalFunctionTable(&_local_function_table_recarga_2_3);
    mclCopyArray(&hObject);
    mclCopyArray(&eventdata);
    mclCopyArray(&handles);
    mxDestroyArray(handles);
    mxDestroyArray(eventdata);
    mxDestroyArray(hObject);
    mclSetCurrentLocalFunctionTable(save_local_function_table_);
    /*
     * % hObject    handle to Evap (see GCBO)
     * % eventdata  reserved - to be defined in a future version of MATLAB
     * % handles    structure with handles and user data (see GUIDATA)
     * 
     * % Hints: get(hObject,'String') returns contents of Evap as text
     * %        str2double(get(hObject,'String')) returns contents of Evap as a double
     * 
     * 
     * % --- Executes during object creation, after setting all properties.
     */
}

/*
 * The function "Mrecarga_2_3_Storage_CreateFcn" is the implementation version
 * of the "recarga_2_3/Storage_CreateFcn" M-function from file
 * "u:\final_recarga6\recarga\recarga_2_3.m" (lines 227-242). It contains the
 * actual compiled code for that M-function. It is a static function and must
 * only be called from one of the interface functions, appearing below.
 */
/*
 * function Storage_CreateFcn(hObject, eventdata, handles)
 */
static void Mrecarga_2_3_Storage_CreateFcn(mxArray * hObject,
                                           mxArray * eventdata,
                                           mxArray * handles) {
    mexLocalFunctionTable save_local_function_table_
      = mclSetCurrentLocalFunctionTable(&_local_function_table_recarga_2_3);
    mxArray * ans = NULL;
    mclCopyArray(&hObject);
    mclCopyArray(&eventdata);
    mclCopyArray(&handles);
    /*
     * % hObject    handle to Storage (see GCBO)
     * % eventdata  reserved - to be defined in a future version of MATLAB
     * % handles    empty - handles not created until after all CreateFcns called
     * 
     * % Hint: edit controls usually have a white background on Windows.
     * %       See ISPC and COMPUTER.
     * if ispc
     */
    if (mlfTobool(mlfIspc())) {
        /*
         * set(hObject,'BackgroundColor','white');
         */
        mclAssignAns(
          &ans,
          mlfNSet(
            0, mclVa(hObject, "hObject"), _mxarray28_, _mxarray30_, NULL));
    /*
     * else
     */
    } else {
        /*
         * set(hObject,'BackgroundColor',get(0,'defaultUicontrolBackgroundColor'));
         */
        mclAssignAns(
          &ans,
          mlfNSet(
            0,
            mclVa(hObject, "hObject"),
            _mxarray28_,
            mlfNGet(1, _mxarray32_, _mxarray33_, NULL),
            NULL));
    /*
     * end
     */
    }
    mxDestroyArray(ans);
    mxDestroyArray(handles);
    mxDestroyArray(eventdata);
    mxDestroyArray(hObject);
    mclSetCurrentLocalFunctionTable(save_local_function_table_);
    /*
     * 
     * 
     * 
     */
}

/*
 * The function "Mrecarga_2_3_Storage_Callback" is the implementation version
 * of the "recarga_2_3/Storage_Callback" M-function from file
 * "u:\final_recarga6\recarga\recarga_2_3.m" (lines 242-252). It contains the
 * actual compiled code for that M-function. It is a static function and must
 * only be called from one of the interface functions, appearing below.
 */
/*
 * function Storage_Callback(hObject, eventdata, handles)
 */
static void Mrecarga_2_3_Storage_Callback(mxArray * hObject,
                                          mxArray * eventdata,
                                          mxArray * handles) {
    mexLocalFunctionTable save_local_function_table_
      = mclSetCurrentLocalFunctionTable(&_local_function_table_recarga_2_3);
    mclCopyArray(&hObject);
    mclCopyArray(&eventdata);
    mclCopyArray(&handles);
    mxDestroyArray(handles);
    mxDestroyArray(eventdata);
    mxDestroyArray(hObject);
    mclSetCurrentLocalFunctionTable(save_local_function_table_);
    /*
     * % hObject    handle to Storage (see GCBO)
     * % eventdata  reserved - to be defined in a future version of MATLAB
     * % handles    structure with handles and user data (see GUIDATA)
     * 
     * % Hints: get(hObject,'String') returns contents of Storage as text
     * %        str2double(get(hObject,'String')) returns contents of Storage as a double
     * 
     * 
     * % --- Executes during object creation, after setting all properties.
     */
}

/*
 * The function "Mrecarga_2_3_Prunon_CreateFcn" is the implementation version
 * of the "recarga_2_3/Prunon_CreateFcn" M-function from file
 * "u:\final_recarga6\recarga\recarga_2_3.m" (lines 252-267). It contains the
 * actual compiled code for that M-function. It is a static function and must
 * only be called from one of the interface functions, appearing below.
 */
/*
 * function Prunon_CreateFcn(hObject, eventdata, handles)
 */
static void Mrecarga_2_3_Prunon_CreateFcn(mxArray * hObject,
                                          mxArray * eventdata,
                                          mxArray * handles) {
    mexLocalFunctionTable save_local_function_table_
      = mclSetCurrentLocalFunctionTable(&_local_function_table_recarga_2_3);
    mxArray * ans = NULL;
    mclCopyArray(&hObject);
    mclCopyArray(&eventdata);
    mclCopyArray(&handles);
    /*
     * % hObject    handle to Prunon (see GCBO)
     * % eventdata  reserved - to be defined in a future version of MATLAB
     * % handles    empty - handles not created until after all CreateFcns called
     * 
     * % Hint: edit controls usually have a white background on Windows.
     * %       See ISPC and COMPUTER.
     * if ispc
     */
    if (mlfTobool(mlfIspc())) {
        /*
         * set(hObject,'BackgroundColor','white');
         */
        mclAssignAns(
          &ans,
          mlfNSet(
            0, mclVa(hObject, "hObject"), _mxarray28_, _mxarray30_, NULL));
    /*
     * else
     */
    } else {
        /*
         * set(hObject,'BackgroundColor',get(0,'defaultUicontrolBackgroundColor'));
         */
        mclAssignAns(
          &ans,
          mlfNSet(
            0,
            mclVa(hObject, "hObject"),
            _mxarray28_,
            mlfNGet(1, _mxarray32_, _mxarray33_, NULL),
            NULL));
    /*
     * end
     */
    }
    mxDestroyArray(ans);
    mxDestroyArray(handles);
    mxDestroyArray(eventdata);
    mxDestroyArray(hObject);
    mclSetCurrentLocalFunctionTable(save_local_function_table_);
    /*
     * 
     * 
     * 
     */
}

/*
 * The function "Mrecarga_2_3_Prunon_Callback" is the implementation version of
 * the "recarga_2_3/Prunon_Callback" M-function from file
 * "u:\final_recarga6\recarga\recarga_2_3.m" (lines 267-277). It contains the
 * actual compiled code for that M-function. It is a static function and must
 * only be called from one of the interface functions, appearing below.
 */
/*
 * function Prunon_Callback(hObject, eventdata, handles)
 */
static void Mrecarga_2_3_Prunon_Callback(mxArray * hObject,
                                         mxArray * eventdata,
                                         mxArray * handles) {
    mexLocalFunctionTable save_local_function_table_
      = mclSetCurrentLocalFunctionTable(&_local_function_table_recarga_2_3);
    mclCopyArray(&hObject);
    mclCopyArray(&eventdata);
    mclCopyArray(&handles);
    mxDestroyArray(handles);
    mxDestroyArray(eventdata);
    mxDestroyArray(hObject);
    mclSetCurrentLocalFunctionTable(save_local_function_table_);
    /*
     * % hObject    handle to Prunon (see GCBO)
     * % eventdata  reserved - to be defined in a future version of MATLAB
     * % handles    structure with handles and user data (see GUIDATA)
     * 
     * % Hints: get(hObject,'String') returns contents of Prunon as text
     * %        str2double(get(hObject,'String')) returns contents of Prunon as a double
     * 
     * 
     * % --- Executes during object creation, after setting all properties.
     */
}

/*
 * The function "Mrecarga_2_3_Prunoff_CreateFcn" is the implementation version
 * of the "recarga_2_3/Prunoff_CreateFcn" M-function from file
 * "u:\final_recarga6\recarga\recarga_2_3.m" (lines 277-292). It contains the
 * actual compiled code for that M-function. It is a static function and must
 * only be called from one of the interface functions, appearing below.
 */
/*
 * function Prunoff_CreateFcn(hObject, eventdata, handles)
 */
static void Mrecarga_2_3_Prunoff_CreateFcn(mxArray * hObject,
                                           mxArray * eventdata,
                                           mxArray * handles) {
    mexLocalFunctionTable save_local_function_table_
      = mclSetCurrentLocalFunctionTable(&_local_function_table_recarga_2_3);
    mxArray * ans = NULL;
    mclCopyArray(&hObject);
    mclCopyArray(&eventdata);
    mclCopyArray(&handles);
    /*
     * % hObject    handle to Prunoff (see GCBO)
     * % eventdata  reserved - to be defined in a future version of MATLAB
     * % handles    empty - handles not created until after all CreateFcns called
     * 
     * % Hint: edit controls usually have a white background on Windows.
     * %       See ISPC and COMPUTER.
     * if ispc
     */
    if (mlfTobool(mlfIspc())) {
        /*
         * set(hObject,'BackgroundColor','white');
         */
        mclAssignAns(
          &ans,
          mlfNSet(
            0, mclVa(hObject, "hObject"), _mxarray28_, _mxarray30_, NULL));
    /*
     * else
     */
    } else {
        /*
         * set(hObject,'BackgroundColor',get(0,'defaultUicontrolBackgroundColor'));
         */
        mclAssignAns(
          &ans,
          mlfNSet(
            0,
            mclVa(hObject, "hObject"),
            _mxarray28_,
            mlfNGet(1, _mxarray32_, _mxarray33_, NULL),
            NULL));
    /*
     * end
     */
    }
    mxDestroyArray(ans);
    mxDestroyArray(handles);
    mxDestroyArray(eventdata);
    mxDestroyArray(hObject);
    mclSetCurrentLocalFunctionTable(save_local_function_table_);
    /*
     * 
     * 
     * 
     */
}

/*
 * The function "Mrecarga_2_3_Prunoff_Callback" is the implementation version
 * of the "recarga_2_3/Prunoff_Callback" M-function from file
 * "u:\final_recarga6\recarga\recarga_2_3.m" (lines 292-302). It contains the
 * actual compiled code for that M-function. It is a static function and must
 * only be called from one of the interface functions, appearing below.
 */
/*
 * function Prunoff_Callback(hObject, eventdata, handles)
 */
static void Mrecarga_2_3_Prunoff_Callback(mxArray * hObject,
                                          mxArray * eventdata,
                                          mxArray * handles) {
    mexLocalFunctionTable save_local_function_table_
      = mclSetCurrentLocalFunctionTable(&_local_function_table_recarga_2_3);
    mclCopyArray(&hObject);
    mclCopyArray(&eventdata);
    mclCopyArray(&handles);
    mxDestroyArray(handles);
    mxDestroyArray(eventdata);
    mxDestroyArray(hObject);
    mclSetCurrentLocalFunctionTable(save_local_function_table_);
    /*
     * % hObject    handle to Prunoff (see GCBO)
     * % eventdata  reserved - to be defined in a future version of MATLAB
     * % handles    structure with handles and user data (see GUIDATA)
     * 
     * % Hints: get(hObject,'String') returns contents of Prunoff as text
     * %        str2double(get(hObject,'String')) returns contents of Prunoff as a double
     * 
     * 
     * % --- Executes during object creation, after setting all properties.
     */
}

/*
 * The function "Mrecarga_2_3_Precharge_CreateFcn" is the implementation
 * version of the "recarga_2_3/Precharge_CreateFcn" M-function from file
 * "u:\final_recarga6\recarga\recarga_2_3.m" (lines 302-317). It contains the
 * actual compiled code for that M-function. It is a static function and must
 * only be called from one of the interface functions, appearing below.
 */
/*
 * function Precharge_CreateFcn(hObject, eventdata, handles)
 */
static void Mrecarga_2_3_Precharge_CreateFcn(mxArray * hObject,
                                             mxArray * eventdata,
                                             mxArray * handles) {
    mexLocalFunctionTable save_local_function_table_
      = mclSetCurrentLocalFunctionTable(&_local_function_table_recarga_2_3);
    mxArray * ans = NULL;
    mclCopyArray(&hObject);
    mclCopyArray(&eventdata);
    mclCopyArray(&handles);
    /*
     * % hObject    handle to Precharge (see GCBO)
     * % eventdata  reserved - to be defined in a future version of MATLAB
     * % handles    empty - handles not created until after all CreateFcns called
     * 
     * % Hint: edit controls usually have a white background on Windows.
     * %       See ISPC and COMPUTER.
     * if ispc
     */
    if (mlfTobool(mlfIspc())) {
        /*
         * set(hObject,'BackgroundColor','white');
         */
        mclAssignAns(
          &ans,
          mlfNSet(
            0, mclVa(hObject, "hObject"), _mxarray28_, _mxarray30_, NULL));
    /*
     * else
     */
    } else {
        /*
         * set(hObject,'BackgroundColor',get(0,'defaultUicontrolBackgroundColor'));
         */
        mclAssignAns(
          &ans,
          mlfNSet(
            0,
            mclVa(hObject, "hObject"),
            _mxarray28_,
            mlfNGet(1, _mxarray32_, _mxarray33_, NULL),
            NULL));
    /*
     * end
     */
    }
    mxDestroyArray(ans);
    mxDestroyArray(handles);
    mxDestroyArray(eventdata);
    mxDestroyArray(hObject);
    mclSetCurrentLocalFunctionTable(save_local_function_table_);
    /*
     * 
     * 
     * 
     */
}

/*
 * The function "Mrecarga_2_3_Precharge_Callback" is the implementation version
 * of the "recarga_2_3/Precharge_Callback" M-function from file
 * "u:\final_recarga6\recarga\recarga_2_3.m" (lines 317-327). It contains the
 * actual compiled code for that M-function. It is a static function and must
 * only be called from one of the interface functions, appearing below.
 */
/*
 * function Precharge_Callback(hObject, eventdata, handles)
 */
static void Mrecarga_2_3_Precharge_Callback(mxArray * hObject,
                                            mxArray * eventdata,
                                            mxArray * handles) {
    mexLocalFunctionTable save_local_function_table_
      = mclSetCurrentLocalFunctionTable(&_local_function_table_recarga_2_3);
    mclCopyArray(&hObject);
    mclCopyArray(&eventdata);
    mclCopyArray(&handles);
    mxDestroyArray(handles);
    mxDestroyArray(eventdata);
    mxDestroyArray(hObject);
    mclSetCurrentLocalFunctionTable(save_local_function_table_);
    /*
     * % hObject    handle to Precharge (see GCBO)
     * % eventdata  reserved - to be defined in a future version of MATLAB
     * % handles    structure with handles and user data (see GUIDATA)
     * 
     * % Hints: get(hObject,'String') returns contents of Precharge as text
     * %        str2double(get(hObject,'String')) returns contents of Precharge as a double
     * 
     * 
     * % --- Executes during object creation, after setting all properties.
     */
}

/*
 * The function "Mrecarga_2_3_Pevap_CreateFcn" is the implementation version of
 * the "recarga_2_3/Pevap_CreateFcn" M-function from file
 * "u:\final_recarga6\recarga\recarga_2_3.m" (lines 327-342). It contains the
 * actual compiled code for that M-function. It is a static function and must
 * only be called from one of the interface functions, appearing below.
 */
/*
 * function Pevap_CreateFcn(hObject, eventdata, handles)
 */
static void Mrecarga_2_3_Pevap_CreateFcn(mxArray * hObject,
                                         mxArray * eventdata,
                                         mxArray * handles) {
    mexLocalFunctionTable save_local_function_table_
      = mclSetCurrentLocalFunctionTable(&_local_function_table_recarga_2_3);
    mxArray * ans = NULL;
    mclCopyArray(&hObject);
    mclCopyArray(&eventdata);
    mclCopyArray(&handles);
    /*
     * % hObject    handle to Pevap (see GCBO)
     * % eventdata  reserved - to be defined in a future version of MATLAB
     * % handles    empty - handles not created until after all CreateFcns called
     * 
     * % Hint: edit controls usually have a white background on Windows.
     * %       See ISPC and COMPUTER.
     * if ispc
     */
    if (mlfTobool(mlfIspc())) {
        /*
         * set(hObject,'BackgroundColor','white');
         */
        mclAssignAns(
          &ans,
          mlfNSet(
            0, mclVa(hObject, "hObject"), _mxarray28_, _mxarray30_, NULL));
    /*
     * else
     */
    } else {
        /*
         * set(hObject,'BackgroundColor',get(0,'defaultUicontrolBackgroundColor'));
         */
        mclAssignAns(
          &ans,
          mlfNSet(
            0,
            mclVa(hObject, "hObject"),
            _mxarray28_,
            mlfNGet(1, _mxarray32_, _mxarray33_, NULL),
            NULL));
    /*
     * end
     */
    }
    mxDestroyArray(ans);
    mxDestroyArray(handles);
    mxDestroyArray(eventdata);
    mxDestroyArray(hObject);
    mclSetCurrentLocalFunctionTable(save_local_function_table_);
    /*
     * 
     * 
     * 
     */
}

/*
 * The function "Mrecarga_2_3_Pevap_Callback" is the implementation version of
 * the "recarga_2_3/Pevap_Callback" M-function from file
 * "u:\final_recarga6\recarga\recarga_2_3.m" (lines 342-352). It contains the
 * actual compiled code for that M-function. It is a static function and must
 * only be called from one of the interface functions, appearing below.
 */
/*
 * function Pevap_Callback(hObject, eventdata, handles)
 */
static void Mrecarga_2_3_Pevap_Callback(mxArray * hObject,
                                        mxArray * eventdata,
                                        mxArray * handles) {
    mexLocalFunctionTable save_local_function_table_
      = mclSetCurrentLocalFunctionTable(&_local_function_table_recarga_2_3);
    mclCopyArray(&hObject);
    mclCopyArray(&eventdata);
    mclCopyArray(&handles);
    mxDestroyArray(handles);
    mxDestroyArray(eventdata);
    mxDestroyArray(hObject);
    mclSetCurrentLocalFunctionTable(save_local_function_table_);
    /*
     * % hObject    handle to Pevap (see GCBO)
     * % eventdata  reserved - to be defined in a future version of MATLAB
     * % handles    structure with handles and user data (see GUIDATA)
     * 
     * % Hints: get(hObject,'String') returns contents of Pevap as text
     * %        str2double(get(hObject,'String')) returns contents of Pevap as a double
     * 
     * 
     * % --- Executes during object creation, after setting all properties.
     */
}

/*
 * The function "Mrecarga_2_3_maxpond_CreateFcn" is the implementation version
 * of the "recarga_2_3/maxpond_CreateFcn" M-function from file
 * "u:\final_recarga6\recarga\recarga_2_3.m" (lines 352-367). It contains the
 * actual compiled code for that M-function. It is a static function and must
 * only be called from one of the interface functions, appearing below.
 */
/*
 * function maxpond_CreateFcn(hObject, eventdata, handles)
 */
static void Mrecarga_2_3_maxpond_CreateFcn(mxArray * hObject,
                                           mxArray * eventdata,
                                           mxArray * handles) {
    mexLocalFunctionTable save_local_function_table_
      = mclSetCurrentLocalFunctionTable(&_local_function_table_recarga_2_3);
    mxArray * ans = NULL;
    mclCopyArray(&hObject);
    mclCopyArray(&eventdata);
    mclCopyArray(&handles);
    /*
     * % hObject    handle to maxpond (see GCBO)
     * % eventdata  reserved - to be defined in a future version of MATLAB
     * % handles    empty - handles not created until after all CreateFcns called
     * 
     * % Hint: edit controls usually have a white background on Windows.
     * %       See ISPC and COMPUTER.
     * if ispc
     */
    if (mlfTobool(mlfIspc())) {
        /*
         * set(hObject,'BackgroundColor','white');
         */
        mclAssignAns(
          &ans,
          mlfNSet(
            0, mclVa(hObject, "hObject"), _mxarray28_, _mxarray30_, NULL));
    /*
     * else
     */
    } else {
        /*
         * set(hObject,'BackgroundColor',get(0,'defaultUicontrolBackgroundColor'));
         */
        mclAssignAns(
          &ans,
          mlfNSet(
            0,
            mclVa(hObject, "hObject"),
            _mxarray28_,
            mlfNGet(1, _mxarray32_, _mxarray33_, NULL),
            NULL));
    /*
     * end
     */
    }
    mxDestroyArray(ans);
    mxDestroyArray(handles);
    mxDestroyArray(eventdata);
    mxDestroyArray(hObject);
    mclSetCurrentLocalFunctionTable(save_local_function_table_);
    /*
     * 
     * 
     * 
     */
}

/*
 * The function "Mrecarga_2_3_maxpond_Callback" is the implementation version
 * of the "recarga_2_3/maxpond_Callback" M-function from file
 * "u:\final_recarga6\recarga\recarga_2_3.m" (lines 367-377). It contains the
 * actual compiled code for that M-function. It is a static function and must
 * only be called from one of the interface functions, appearing below.
 */
/*
 * function maxpond_Callback(hObject, eventdata, handles)
 */
static void Mrecarga_2_3_maxpond_Callback(mxArray * hObject,
                                          mxArray * eventdata,
                                          mxArray * handles) {
    mexLocalFunctionTable save_local_function_table_
      = mclSetCurrentLocalFunctionTable(&_local_function_table_recarga_2_3);
    mclCopyArray(&hObject);
    mclCopyArray(&eventdata);
    mclCopyArray(&handles);
    mxDestroyArray(handles);
    mxDestroyArray(eventdata);
    mxDestroyArray(hObject);
    mclSetCurrentLocalFunctionTable(save_local_function_table_);
    /*
     * % hObject    handle to maxpond (see GCBO)
     * % eventdata  reserved - to be defined in a future version of MATLAB
     * % handles    structure with handles and user data (see GUIDATA)
     * 
     * % Hints: get(hObject,'String') returns contents of maxpond as text
     * %        str2double(get(hObject,'String')) returns contents of maxpond as a double
     * 
     * 
     * % --- Executes during object creation, after setting all properties.
     */
}

/*
 * The function "Mrecarga_2_3_maxwilt_CreateFcn" is the implementation version
 * of the "recarga_2_3/maxwilt_CreateFcn" M-function from file
 * "u:\final_recarga6\recarga\recarga_2_3.m" (lines 377-392). It contains the
 * actual compiled code for that M-function. It is a static function and must
 * only be called from one of the interface functions, appearing below.
 */
/*
 * function maxwilt_CreateFcn(hObject, eventdata, handles)
 */
static void Mrecarga_2_3_maxwilt_CreateFcn(mxArray * hObject,
                                           mxArray * eventdata,
                                           mxArray * handles) {
    mexLocalFunctionTable save_local_function_table_
      = mclSetCurrentLocalFunctionTable(&_local_function_table_recarga_2_3);
    mxArray * ans = NULL;
    mclCopyArray(&hObject);
    mclCopyArray(&eventdata);
    mclCopyArray(&handles);
    /*
     * % hObject    handle to maxwilt (see GCBO)
     * % eventdata  reserved - to be defined in a future version of MATLAB
     * % handles    empty - handles not created until after all CreateFcns called
     * 
     * % Hint: edit controls usually have a white background on Windows.
     * %       See ISPC and COMPUTER.
     * if ispc
     */
    if (mlfTobool(mlfIspc())) {
        /*
         * set(hObject,'BackgroundColor','white');
         */
        mclAssignAns(
          &ans,
          mlfNSet(
            0, mclVa(hObject, "hObject"), _mxarray28_, _mxarray30_, NULL));
    /*
     * else
     */
    } else {
        /*
         * set(hObject,'BackgroundColor',get(0,'defaultUicontrolBackgroundColor'));
         */
        mclAssignAns(
          &ans,
          mlfNSet(
            0,
            mclVa(hObject, "hObject"),
            _mxarray28_,
            mlfNGet(1, _mxarray32_, _mxarray33_, NULL),
            NULL));
    /*
     * end
     */
    }
    mxDestroyArray(ans);
    mxDestroyArray(handles);
    mxDestroyArray(eventdata);
    mxDestroyArray(hObject);
    mclSetCurrentLocalFunctionTable(save_local_function_table_);
    /*
     * 
     * 
     * 
     */
}

/*
 * The function "Mrecarga_2_3_maxwilt_Callback" is the implementation version
 * of the "recarga_2_3/maxwilt_Callback" M-function from file
 * "u:\final_recarga6\recarga\recarga_2_3.m" (lines 392-402). It contains the
 * actual compiled code for that M-function. It is a static function and must
 * only be called from one of the interface functions, appearing below.
 */
/*
 * function maxwilt_Callback(hObject, eventdata, handles)
 */
static void Mrecarga_2_3_maxwilt_Callback(mxArray * hObject,
                                          mxArray * eventdata,
                                          mxArray * handles) {
    mexLocalFunctionTable save_local_function_table_
      = mclSetCurrentLocalFunctionTable(&_local_function_table_recarga_2_3);
    mclCopyArray(&hObject);
    mclCopyArray(&eventdata);
    mclCopyArray(&handles);
    mxDestroyArray(handles);
    mxDestroyArray(eventdata);
    mxDestroyArray(hObject);
    mclSetCurrentLocalFunctionTable(save_local_function_table_);
    /*
     * % hObject    handle to maxwilt (see GCBO)
     * % eventdata  reserved - to be defined in a future version of MATLAB
     * % handles    structure with handles and user data (see GUIDATA)
     * 
     * % Hints: get(hObject,'String') returns contents of maxwilt as text
     * %        str2double(get(hObject,'String')) returns contents of maxwilt as a double
     * 
     * 
     * % --- Executes during object creation, after setting all properties.
     */
}

/*
 * The function "Mrecarga_2_3_tpond_CreateFcn" is the implementation version of
 * the "recarga_2_3/tpond_CreateFcn" M-function from file
 * "u:\final_recarga6\recarga\recarga_2_3.m" (lines 402-417). It contains the
 * actual compiled code for that M-function. It is a static function and must
 * only be called from one of the interface functions, appearing below.
 */
/*
 * function tpond_CreateFcn(hObject, eventdata, handles)
 */
static void Mrecarga_2_3_tpond_CreateFcn(mxArray * hObject,
                                         mxArray * eventdata,
                                         mxArray * handles) {
    mexLocalFunctionTable save_local_function_table_
      = mclSetCurrentLocalFunctionTable(&_local_function_table_recarga_2_3);
    mxArray * ans = NULL;
    mclCopyArray(&hObject);
    mclCopyArray(&eventdata);
    mclCopyArray(&handles);
    /*
     * % hObject    handle to tpond (see GCBO)
     * % eventdata  reserved - to be defined in a future version of MATLAB
     * % handles    empty - handles not created until after all CreateFcns called
     * 
     * % Hint: edit controls usually have a white background on Windows.
     * %       See ISPC and COMPUTER.
     * if ispc
     */
    if (mlfTobool(mlfIspc())) {
        /*
         * set(hObject,'BackgroundColor','white');
         */
        mclAssignAns(
          &ans,
          mlfNSet(
            0, mclVa(hObject, "hObject"), _mxarray28_, _mxarray30_, NULL));
    /*
     * else
     */
    } else {
        /*
         * set(hObject,'BackgroundColor',get(0,'defaultUicontrolBackgroundColor'));
         */
        mclAssignAns(
          &ans,
          mlfNSet(
            0,
            mclVa(hObject, "hObject"),
            _mxarray28_,
            mlfNGet(1, _mxarray32_, _mxarray33_, NULL),
            NULL));
    /*
     * end
     */
    }
    mxDestroyArray(ans);
    mxDestroyArray(handles);
    mxDestroyArray(eventdata);
    mxDestroyArray(hObject);
    mclSetCurrentLocalFunctionTable(save_local_function_table_);
    /*
     * 
     * 
     * 
     */
}

/*
 * The function "Mrecarga_2_3_tpond_Callback" is the implementation version of
 * the "recarga_2_3/tpond_Callback" M-function from file
 * "u:\final_recarga6\recarga\recarga_2_3.m" (lines 417-427). It contains the
 * actual compiled code for that M-function. It is a static function and must
 * only be called from one of the interface functions, appearing below.
 */
/*
 * function tpond_Callback(hObject, eventdata, handles)
 */
static void Mrecarga_2_3_tpond_Callback(mxArray * hObject,
                                        mxArray * eventdata,
                                        mxArray * handles) {
    mexLocalFunctionTable save_local_function_table_
      = mclSetCurrentLocalFunctionTable(&_local_function_table_recarga_2_3);
    mclCopyArray(&hObject);
    mclCopyArray(&eventdata);
    mclCopyArray(&handles);
    mxDestroyArray(handles);
    mxDestroyArray(eventdata);
    mxDestroyArray(hObject);
    mclSetCurrentLocalFunctionTable(save_local_function_table_);
    /*
     * % hObject    handle to tpond (see GCBO)
     * % eventdata  reserved - to be defined in a future version of MATLAB
     * % handles    structure with handles and user data (see GUIDATA)
     * 
     * % Hints: get(hObject,'String') returns contents of tpond as text
     * %        str2double(get(hObject,'String')) returns contents of tpond as a double
     * 
     * 
     * % --- Executes during object creation, after setting all properties.
     */
}

/*
 * The function "Mrecarga_2_3_OFtimes_CreateFcn" is the implementation version
 * of the "recarga_2_3/OFtimes_CreateFcn" M-function from file
 * "u:\final_recarga6\recarga\recarga_2_3.m" (lines 427-442). It contains the
 * actual compiled code for that M-function. It is a static function and must
 * only be called from one of the interface functions, appearing below.
 */
/*
 * function OFtimes_CreateFcn(hObject, eventdata, handles)
 */
static void Mrecarga_2_3_OFtimes_CreateFcn(mxArray * hObject,
                                           mxArray * eventdata,
                                           mxArray * handles) {
    mexLocalFunctionTable save_local_function_table_
      = mclSetCurrentLocalFunctionTable(&_local_function_table_recarga_2_3);
    mxArray * ans = NULL;
    mclCopyArray(&hObject);
    mclCopyArray(&eventdata);
    mclCopyArray(&handles);
    /*
     * % hObject    handle to OFtimes (see GCBO)
     * % eventdata  reserved - to be defined in a future version of MATLAB
     * % handles    empty - handles not created until after all CreateFcns called
     * 
     * % Hint: edit controls usually have a white background on Windows.
     * %       See ISPC and COMPUTER.
     * if ispc
     */
    if (mlfTobool(mlfIspc())) {
        /*
         * set(hObject,'BackgroundColor','white');
         */
        mclAssignAns(
          &ans,
          mlfNSet(
            0, mclVa(hObject, "hObject"), _mxarray28_, _mxarray30_, NULL));
    /*
     * else
     */
    } else {
        /*
         * set(hObject,'BackgroundColor',get(0,'defaultUicontrolBackgroundColor'));
         */
        mclAssignAns(
          &ans,
          mlfNSet(
            0,
            mclVa(hObject, "hObject"),
            _mxarray28_,
            mlfNGet(1, _mxarray32_, _mxarray33_, NULL),
            NULL));
    /*
     * end
     */
    }
    mxDestroyArray(ans);
    mxDestroyArray(handles);
    mxDestroyArray(eventdata);
    mxDestroyArray(hObject);
    mclSetCurrentLocalFunctionTable(save_local_function_table_);
    /*
     * 
     * 
     * 
     */
}

/*
 * The function "Mrecarga_2_3_OFtimes_Callback" is the implementation version
 * of the "recarga_2_3/OFtimes_Callback" M-function from file
 * "u:\final_recarga6\recarga\recarga_2_3.m" (lines 442-452). It contains the
 * actual compiled code for that M-function. It is a static function and must
 * only be called from one of the interface functions, appearing below.
 */
/*
 * function OFtimes_Callback(hObject, eventdata, handles)
 */
static void Mrecarga_2_3_OFtimes_Callback(mxArray * hObject,
                                          mxArray * eventdata,
                                          mxArray * handles) {
    mexLocalFunctionTable save_local_function_table_
      = mclSetCurrentLocalFunctionTable(&_local_function_table_recarga_2_3);
    mclCopyArray(&hObject);
    mclCopyArray(&eventdata);
    mclCopyArray(&handles);
    mxDestroyArray(handles);
    mxDestroyArray(eventdata);
    mxDestroyArray(hObject);
    mclSetCurrentLocalFunctionTable(save_local_function_table_);
    /*
     * % hObject    handle to OFtimes (see GCBO)
     * % eventdata  reserved - to be defined in a future version of MATLAB
     * % handles    structure with handles and user data (see GUIDATA)
     * 
     * % Hints: get(hObject,'String') returns contents of OFtimes as text
     * %        str2double(get(hObject,'String')) returns contents of OFtimes as a double
     * 
     * 
     * % --- Executes during object creation, after setting all properties.
     */
}

/*
 * The function "Mrecarga_2_3_ImpA_CreateFcn" is the implementation version of
 * the "recarga_2_3/ImpA_CreateFcn" M-function from file
 * "u:\final_recarga6\recarga\recarga_2_3.m" (lines 452-467). It contains the
 * actual compiled code for that M-function. It is a static function and must
 * only be called from one of the interface functions, appearing below.
 */
/*
 * function ImpA_CreateFcn(hObject, eventdata, handles)
 */
static void Mrecarga_2_3_ImpA_CreateFcn(mxArray * hObject,
                                        mxArray * eventdata,
                                        mxArray * handles) {
    mexLocalFunctionTable save_local_function_table_
      = mclSetCurrentLocalFunctionTable(&_local_function_table_recarga_2_3);
    mxArray * ans = NULL;
    mclCopyArray(&hObject);
    mclCopyArray(&eventdata);
    mclCopyArray(&handles);
    /*
     * % hObject    handle to ImpA (see GCBO)
     * % eventdata  reserved - to be defined in a future version of MATLAB
     * % handles    empty - handles not created until after all CreateFcns called
     * 
     * % Hint: edit controls usually have a white background on Windows.
     * %       See ISPC and COMPUTER.
     * if ispc
     */
    if (mlfTobool(mlfIspc())) {
        /*
         * set(hObject,'BackgroundColor','white');
         */
        mclAssignAns(
          &ans,
          mlfNSet(
            0, mclVa(hObject, "hObject"), _mxarray28_, _mxarray30_, NULL));
    /*
     * else
     */
    } else {
        /*
         * set(hObject,'BackgroundColor',get(0,'defaultUicontrolBackgroundColor'));
         */
        mclAssignAns(
          &ans,
          mlfNSet(
            0,
            mclVa(hObject, "hObject"),
            _mxarray28_,
            mlfNGet(1, _mxarray32_, _mxarray33_, NULL),
            NULL));
    /*
     * end
     */
    }
    mxDestroyArray(ans);
    mxDestroyArray(handles);
    mxDestroyArray(eventdata);
    mxDestroyArray(hObject);
    mclSetCurrentLocalFunctionTable(save_local_function_table_);
    /*
     * 
     * 
     * 
     */
}

/*
 * The function "Mrecarga_2_3_ImpA_Callback" is the implementation version of
 * the "recarga_2_3/ImpA_Callback" M-function from file
 * "u:\final_recarga6\recarga\recarga_2_3.m" (lines 467-477). It contains the
 * actual compiled code for that M-function. It is a static function and must
 * only be called from one of the interface functions, appearing below.
 */
/*
 * function ImpA_Callback(hObject, eventdata, handles)
 */
static void Mrecarga_2_3_ImpA_Callback(mxArray * hObject,
                                       mxArray * eventdata,
                                       mxArray * handles) {
    mexLocalFunctionTable save_local_function_table_
      = mclSetCurrentLocalFunctionTable(&_local_function_table_recarga_2_3);
    mclCopyArray(&hObject);
    mclCopyArray(&eventdata);
    mclCopyArray(&handles);
    mxDestroyArray(handles);
    mxDestroyArray(eventdata);
    mxDestroyArray(hObject);
    mclSetCurrentLocalFunctionTable(save_local_function_table_);
    /*
     * % hObject    handle to ImpA (see GCBO)
     * % eventdata  reserved - to be defined in a future version of MATLAB
     * % handles    structure with handles and user data (see GUIDATA)
     * 
     * % Hints: get(hObject,'String') returns contents of ImpA as text
     * %        str2double(get(hObject,'String')) returns contents of ImpA as a double
     * 
     * 
     * % --- Executes during object creation, after setting all properties.
     */
}

/*
 * The function "Mrecarga_2_3_CN_CreateFcn" is the implementation version of
 * the "recarga_2_3/CN_CreateFcn" M-function from file
 * "u:\final_recarga6\recarga\recarga_2_3.m" (lines 477-492). It contains the
 * actual compiled code for that M-function. It is a static function and must
 * only be called from one of the interface functions, appearing below.
 */
/*
 * function CN_CreateFcn(hObject, eventdata, handles)
 */
static void Mrecarga_2_3_CN_CreateFcn(mxArray * hObject,
                                      mxArray * eventdata,
                                      mxArray * handles) {
    mexLocalFunctionTable save_local_function_table_
      = mclSetCurrentLocalFunctionTable(&_local_function_table_recarga_2_3);
    mxArray * ans = NULL;
    mclCopyArray(&hObject);
    mclCopyArray(&eventdata);
    mclCopyArray(&handles);
    /*
     * % hObject    handle to CN (see GCBO)
     * % eventdata  reserved - to be defined in a future version of MATLAB
     * % handles    empty - handles not created until after all CreateFcns called
     * 
     * % Hint: edit controls usually have a white background on Windows.
     * %       See ISPC and COMPUTER.
     * if ispc
     */
    if (mlfTobool(mlfIspc())) {
        /*
         * set(hObject,'BackgroundColor','white');
         */
        mclAssignAns(
          &ans,
          mlfNSet(
            0, mclVa(hObject, "hObject"), _mxarray28_, _mxarray30_, NULL));
    /*
     * else
     */
    } else {
        /*
         * set(hObject,'BackgroundColor',get(0,'defaultUicontrolBackgroundColor'));
         */
        mclAssignAns(
          &ans,
          mlfNSet(
            0,
            mclVa(hObject, "hObject"),
            _mxarray28_,
            mlfNGet(1, _mxarray32_, _mxarray33_, NULL),
            NULL));
    /*
     * end
     */
    }
    mxDestroyArray(ans);
    mxDestroyArray(handles);
    mxDestroyArray(eventdata);
    mxDestroyArray(hObject);
    mclSetCurrentLocalFunctionTable(save_local_function_table_);
    /*
     * 
     * 
     * 
     */
}

/*
 * The function "Mrecarga_2_3_CN_Callback" is the implementation version of the
 * "recarga_2_3/CN_Callback" M-function from file
 * "u:\final_recarga6\recarga\recarga_2_3.m" (lines 492-502). It contains the
 * actual compiled code for that M-function. It is a static function and must
 * only be called from one of the interface functions, appearing below.
 */
/*
 * function CN_Callback(hObject, eventdata, handles)
 */
static void Mrecarga_2_3_CN_Callback(mxArray * hObject,
                                     mxArray * eventdata,
                                     mxArray * handles) {
    mexLocalFunctionTable save_local_function_table_
      = mclSetCurrentLocalFunctionTable(&_local_function_table_recarga_2_3);
    mclCopyArray(&hObject);
    mclCopyArray(&eventdata);
    mclCopyArray(&handles);
    mxDestroyArray(handles);
    mxDestroyArray(eventdata);
    mxDestroyArray(hObject);
    mclSetCurrentLocalFunctionTable(save_local_function_table_);
    /*
     * % hObject    handle to CN (see GCBO)
     * % eventdata  reserved - to be defined in a future version of MATLAB
     * % handles    structure with handles and user data (see GUIDATA)
     * 
     * % Hints: get(hObject,'String') returns contents of CN as text
     * %        str2double(get(hObject,'String')) returns contents of CN as a double
     * 
     * 
     * % --- Executes during object creation, after setting all properties.
     */
}

/*
 * The function "Mrecarga_2_3_ImpVol_CreateFcn" is the implementation version
 * of the "recarga_2_3/ImpVol_CreateFcn" M-function from file
 * "u:\final_recarga6\recarga\recarga_2_3.m" (lines 502-517). It contains the
 * actual compiled code for that M-function. It is a static function and must
 * only be called from one of the interface functions, appearing below.
 */
/*
 * function ImpVol_CreateFcn(hObject, eventdata, handles)
 */
static void Mrecarga_2_3_ImpVol_CreateFcn(mxArray * hObject,
                                          mxArray * eventdata,
                                          mxArray * handles) {
    mexLocalFunctionTable save_local_function_table_
      = mclSetCurrentLocalFunctionTable(&_local_function_table_recarga_2_3);
    mxArray * ans = NULL;
    mclCopyArray(&hObject);
    mclCopyArray(&eventdata);
    mclCopyArray(&handles);
    /*
     * % hObject    handle to ImpVol (see GCBO)
     * % eventdata  reserved - to be defined in a future version of MATLAB
     * % handles    empty - handles not created until after all CreateFcns called
     * 
     * % Hint: edit controls usually have a white background on Windows.
     * %       See ISPC and COMPUTER.
     * if ispc
     */
    if (mlfTobool(mlfIspc())) {
        /*
         * set(hObject,'BackgroundColor','white');
         */
        mclAssignAns(
          &ans,
          mlfNSet(
            0, mclVa(hObject, "hObject"), _mxarray28_, _mxarray30_, NULL));
    /*
     * else
     */
    } else {
        /*
         * set(hObject,'BackgroundColor',get(0,'defaultUicontrolBackgroundColor'));
         */
        mclAssignAns(
          &ans,
          mlfNSet(
            0,
            mclVa(hObject, "hObject"),
            _mxarray28_,
            mlfNGet(1, _mxarray32_, _mxarray33_, NULL),
            NULL));
    /*
     * end
     */
    }
    mxDestroyArray(ans);
    mxDestroyArray(handles);
    mxDestroyArray(eventdata);
    mxDestroyArray(hObject);
    mclSetCurrentLocalFunctionTable(save_local_function_table_);
    /*
     * 
     * 
     * 
     */
}

/*
 * The function "Mrecarga_2_3_ImpVol_Callback" is the implementation version of
 * the "recarga_2_3/ImpVol_Callback" M-function from file
 * "u:\final_recarga6\recarga\recarga_2_3.m" (lines 517-527). It contains the
 * actual compiled code for that M-function. It is a static function and must
 * only be called from one of the interface functions, appearing below.
 */
/*
 * function ImpVol_Callback(hObject, eventdata, handles)
 */
static void Mrecarga_2_3_ImpVol_Callback(mxArray * hObject,
                                         mxArray * eventdata,
                                         mxArray * handles) {
    mexLocalFunctionTable save_local_function_table_
      = mclSetCurrentLocalFunctionTable(&_local_function_table_recarga_2_3);
    mclCopyArray(&hObject);
    mclCopyArray(&eventdata);
    mclCopyArray(&handles);
    mxDestroyArray(handles);
    mxDestroyArray(eventdata);
    mxDestroyArray(hObject);
    mclSetCurrentLocalFunctionTable(save_local_function_table_);
    /*
     * % hObject    handle to ImpVol (see GCBO)
     * % eventdata  reserved - to be defined in a future version of MATLAB
     * % handles    structure with handles and user data (see GUIDATA)
     * 
     * % Hints: get(hObject,'String') returns contents of ImpVol as text
     * %        str2double(get(hObject,'String')) returns contents of ImpVol as a double
     * 
     * 
     * % --- Executes during object creation, after setting all properties.
     */
}

/*
 * The function "Mrecarga_2_3_PervVol_CreateFcn" is the implementation version
 * of the "recarga_2_3/PervVol_CreateFcn" M-function from file
 * "u:\final_recarga6\recarga\recarga_2_3.m" (lines 527-542). It contains the
 * actual compiled code for that M-function. It is a static function and must
 * only be called from one of the interface functions, appearing below.
 */
/*
 * function PervVol_CreateFcn(hObject, eventdata, handles)
 */
static void Mrecarga_2_3_PervVol_CreateFcn(mxArray * hObject,
                                           mxArray * eventdata,
                                           mxArray * handles) {
    mexLocalFunctionTable save_local_function_table_
      = mclSetCurrentLocalFunctionTable(&_local_function_table_recarga_2_3);
    mxArray * ans = NULL;
    mclCopyArray(&hObject);
    mclCopyArray(&eventdata);
    mclCopyArray(&handles);
    /*
     * % hObject    handle to PervVol (see GCBO)
     * % eventdata  reserved - to be defined in a future version of MATLAB
     * % handles    empty - handles not created until after all CreateFcns called
     * 
     * % Hint: edit controls usually have a white background on Windows.
     * %       See ISPC and COMPUTER.
     * if ispc
     */
    if (mlfTobool(mlfIspc())) {
        /*
         * set(hObject,'BackgroundColor','white');
         */
        mclAssignAns(
          &ans,
          mlfNSet(
            0, mclVa(hObject, "hObject"), _mxarray28_, _mxarray30_, NULL));
    /*
     * else
     */
    } else {
        /*
         * set(hObject,'BackgroundColor',get(0,'defaultUicontrolBackgroundColor'));
         */
        mclAssignAns(
          &ans,
          mlfNSet(
            0,
            mclVa(hObject, "hObject"),
            _mxarray28_,
            mlfNGet(1, _mxarray32_, _mxarray33_, NULL),
            NULL));
    /*
     * end
     */
    }
    mxDestroyArray(ans);
    mxDestroyArray(handles);
    mxDestroyArray(eventdata);
    mxDestroyArray(hObject);
    mclSetCurrentLocalFunctionTable(save_local_function_table_);
    /*
     * 
     * 
     * 
     */
}

/*
 * The function "Mrecarga_2_3_PervVol_Callback" is the implementation version
 * of the "recarga_2_3/PervVol_Callback" M-function from file
 * "u:\final_recarga6\recarga\recarga_2_3.m" (lines 542-552). It contains the
 * actual compiled code for that M-function. It is a static function and must
 * only be called from one of the interface functions, appearing below.
 */
/*
 * function PervVol_Callback(hObject, eventdata, handles)
 */
static void Mrecarga_2_3_PervVol_Callback(mxArray * hObject,
                                          mxArray * eventdata,
                                          mxArray * handles) {
    mexLocalFunctionTable save_local_function_table_
      = mclSetCurrentLocalFunctionTable(&_local_function_table_recarga_2_3);
    mclCopyArray(&hObject);
    mclCopyArray(&eventdata);
    mclCopyArray(&handles);
    mxDestroyArray(handles);
    mxDestroyArray(eventdata);
    mxDestroyArray(hObject);
    mclSetCurrentLocalFunctionTable(save_local_function_table_);
    /*
     * % hObject    handle to PervVol (see GCBO)
     * % eventdata  reserved - to be defined in a future version of MATLAB
     * % handles    structure with handles and user data (see GUIDATA)
     * 
     * % Hints: get(hObject,'String') returns contents of PervVol as text
     * %        str2double(get(hObject,'String')) returns contents of PervVol as a double
     * 
     * 
     * % --- Executes during object creation, after setting all properties.
     */
}

/*
 * The function "Mrecarga_2_3_ImpDpth_CreateFcn" is the implementation version
 * of the "recarga_2_3/ImpDpth_CreateFcn" M-function from file
 * "u:\final_recarga6\recarga\recarga_2_3.m" (lines 552-567). It contains the
 * actual compiled code for that M-function. It is a static function and must
 * only be called from one of the interface functions, appearing below.
 */
/*
 * function ImpDpth_CreateFcn(hObject, eventdata, handles)
 */
static void Mrecarga_2_3_ImpDpth_CreateFcn(mxArray * hObject,
                                           mxArray * eventdata,
                                           mxArray * handles) {
    mexLocalFunctionTable save_local_function_table_
      = mclSetCurrentLocalFunctionTable(&_local_function_table_recarga_2_3);
    mxArray * ans = NULL;
    mclCopyArray(&hObject);
    mclCopyArray(&eventdata);
    mclCopyArray(&handles);
    /*
     * % hObject    handle to ImpDpth (see GCBO)
     * % eventdata  reserved - to be defined in a future version of MATLAB
     * % handles    empty - handles not created until after all CreateFcns called
     * 
     * % Hint: edit controls usually have a white background on Windows.
     * %       See ISPC and COMPUTER.
     * if ispc
     */
    if (mlfTobool(mlfIspc())) {
        /*
         * set(hObject,'BackgroundColor','white');
         */
        mclAssignAns(
          &ans,
          mlfNSet(
            0, mclVa(hObject, "hObject"), _mxarray28_, _mxarray30_, NULL));
    /*
     * else
     */
    } else {
        /*
         * set(hObject,'BackgroundColor',get(0,'defaultUicontrolBackgroundColor'));
         */
        mclAssignAns(
          &ans,
          mlfNSet(
            0,
            mclVa(hObject, "hObject"),
            _mxarray28_,
            mlfNGet(1, _mxarray32_, _mxarray33_, NULL),
            NULL));
    /*
     * end
     */
    }
    mxDestroyArray(ans);
    mxDestroyArray(handles);
    mxDestroyArray(eventdata);
    mxDestroyArray(hObject);
    mclSetCurrentLocalFunctionTable(save_local_function_table_);
    /*
     * 
     * 
     * 
     */
}

/*
 * The function "Mrecarga_2_3_ImpDpth_Callback" is the implementation version
 * of the "recarga_2_3/ImpDpth_Callback" M-function from file
 * "u:\final_recarga6\recarga\recarga_2_3.m" (lines 567-577). It contains the
 * actual compiled code for that M-function. It is a static function and must
 * only be called from one of the interface functions, appearing below.
 */
/*
 * function ImpDpth_Callback(hObject, eventdata, handles)
 */
static void Mrecarga_2_3_ImpDpth_Callback(mxArray * hObject,
                                          mxArray * eventdata,
                                          mxArray * handles) {
    mexLocalFunctionTable save_local_function_table_
      = mclSetCurrentLocalFunctionTable(&_local_function_table_recarga_2_3);
    mclCopyArray(&hObject);
    mclCopyArray(&eventdata);
    mclCopyArray(&handles);
    mxDestroyArray(handles);
    mxDestroyArray(eventdata);
    mxDestroyArray(hObject);
    mclSetCurrentLocalFunctionTable(save_local_function_table_);
    /*
     * % hObject    handle to ImpDpth (see GCBO)
     * % eventdata  reserved - to be defined in a future version of MATLAB
     * % handles    structure with handles and user data (see GUIDATA)
     * 
     * % Hints: get(hObject,'String') returns contents of ImpDpth as text
     * %        str2double(get(hObject,'String')) returns contents of ImpDpth as a double
     * 
     * 
     * % --- Executes during object creation, after setting all properties.
     */
}

/*
 * The function "Mrecarga_2_3_PervDpth_CreateFcn" is the implementation version
 * of the "recarga_2_3/PervDpth_CreateFcn" M-function from file
 * "u:\final_recarga6\recarga\recarga_2_3.m" (lines 577-592). It contains the
 * actual compiled code for that M-function. It is a static function and must
 * only be called from one of the interface functions, appearing below.
 */
/*
 * function PervDpth_CreateFcn(hObject, eventdata, handles)
 */
static void Mrecarga_2_3_PervDpth_CreateFcn(mxArray * hObject,
                                            mxArray * eventdata,
                                            mxArray * handles) {
    mexLocalFunctionTable save_local_function_table_
      = mclSetCurrentLocalFunctionTable(&_local_function_table_recarga_2_3);
    mxArray * ans = NULL;
    mclCopyArray(&hObject);
    mclCopyArray(&eventdata);
    mclCopyArray(&handles);
    /*
     * % hObject    handle to PervDpth (see GCBO)
     * % eventdata  reserved - to be defined in a future version of MATLAB
     * % handles    empty - handles not created until after all CreateFcns called
     * 
     * % Hint: edit controls usually have a white background on Windows.
     * %       See ISPC and COMPUTER.
     * if ispc
     */
    if (mlfTobool(mlfIspc())) {
        /*
         * set(hObject,'BackgroundColor','white');
         */
        mclAssignAns(
          &ans,
          mlfNSet(
            0, mclVa(hObject, "hObject"), _mxarray28_, _mxarray30_, NULL));
    /*
     * else
     */
    } else {
        /*
         * set(hObject,'BackgroundColor',get(0,'defaultUicontrolBackgroundColor'));
         */
        mclAssignAns(
          &ans,
          mlfNSet(
            0,
            mclVa(hObject, "hObject"),
            _mxarray28_,
            mlfNGet(1, _mxarray32_, _mxarray33_, NULL),
            NULL));
    /*
     * end
     */
    }
    mxDestroyArray(ans);
    mxDestroyArray(handles);
    mxDestroyArray(eventdata);
    mxDestroyArray(hObject);
    mclSetCurrentLocalFunctionTable(save_local_function_table_);
    /*
     * 
     * 
     * 
     */
}

/*
 * The function "Mrecarga_2_3_PervDpth_Callback" is the implementation version
 * of the "recarga_2_3/PervDpth_Callback" M-function from file
 * "u:\final_recarga6\recarga\recarga_2_3.m" (lines 592-602). It contains the
 * actual compiled code for that M-function. It is a static function and must
 * only be called from one of the interface functions, appearing below.
 */
/*
 * function PervDpth_Callback(hObject, eventdata, handles)
 */
static void Mrecarga_2_3_PervDpth_Callback(mxArray * hObject,
                                           mxArray * eventdata,
                                           mxArray * handles) {
    mexLocalFunctionTable save_local_function_table_
      = mclSetCurrentLocalFunctionTable(&_local_function_table_recarga_2_3);
    mclCopyArray(&hObject);
    mclCopyArray(&eventdata);
    mclCopyArray(&handles);
    mxDestroyArray(handles);
    mxDestroyArray(eventdata);
    mxDestroyArray(hObject);
    mclSetCurrentLocalFunctionTable(save_local_function_table_);
    /*
     * % hObject    handle to PervDpth (see GCBO)
     * % eventdata  reserved - to be defined in a future version of MATLAB
     * % handles    structure with handles and user data (see GUIDATA)
     * 
     * % Hints: get(hObject,'String') returns contents of PervDpth as text
     * %        str2double(get(hObject,'String')) returns contents of PervDpth as a double
     * 
     * 
     * % --- Executes during object creation, after setting all properties.
     */
}

/*
 * The function "Mrecarga_2_3_RoffDpth_CreateFcn" is the implementation version
 * of the "recarga_2_3/RoffDpth_CreateFcn" M-function from file
 * "u:\final_recarga6\recarga\recarga_2_3.m" (lines 602-617). It contains the
 * actual compiled code for that M-function. It is a static function and must
 * only be called from one of the interface functions, appearing below.
 */
/*
 * function RoffDpth_CreateFcn(hObject, eventdata, handles)
 */
static void Mrecarga_2_3_RoffDpth_CreateFcn(mxArray * hObject,
                                            mxArray * eventdata,
                                            mxArray * handles) {
    mexLocalFunctionTable save_local_function_table_
      = mclSetCurrentLocalFunctionTable(&_local_function_table_recarga_2_3);
    mxArray * ans = NULL;
    mclCopyArray(&hObject);
    mclCopyArray(&eventdata);
    mclCopyArray(&handles);
    /*
     * % hObject    handle to RoffDpth (see GCBO)
     * % eventdata  reserved - to be defined in a future version of MATLAB
     * % handles    empty - handles not created until after all CreateFcns called
     * 
     * % Hint: edit controls usually have a white background on Windows.
     * %       See ISPC and COMPUTER.
     * if ispc
     */
    if (mlfTobool(mlfIspc())) {
        /*
         * set(hObject,'BackgroundColor','white');
         */
        mclAssignAns(
          &ans,
          mlfNSet(
            0, mclVa(hObject, "hObject"), _mxarray28_, _mxarray30_, NULL));
    /*
     * else
     */
    } else {
        /*
         * set(hObject,'BackgroundColor',get(0,'defaultUicontrolBackgroundColor'));
         */
        mclAssignAns(
          &ans,
          mlfNSet(
            0,
            mclVa(hObject, "hObject"),
            _mxarray28_,
            mlfNGet(1, _mxarray32_, _mxarray33_, NULL),
            NULL));
    /*
     * end
     */
    }
    mxDestroyArray(ans);
    mxDestroyArray(handles);
    mxDestroyArray(eventdata);
    mxDestroyArray(hObject);
    mclSetCurrentLocalFunctionTable(save_local_function_table_);
    /*
     * 
     * 
     * 
     */
}

/*
 * The function "Mrecarga_2_3_RoffDpth_Callback" is the implementation version
 * of the "recarga_2_3/RoffDpth_Callback" M-function from file
 * "u:\final_recarga6\recarga\recarga_2_3.m" (lines 617-627). It contains the
 * actual compiled code for that M-function. It is a static function and must
 * only be called from one of the interface functions, appearing below.
 */
/*
 * function RoffDpth_Callback(hObject, eventdata, handles)
 */
static void Mrecarga_2_3_RoffDpth_Callback(mxArray * hObject,
                                           mxArray * eventdata,
                                           mxArray * handles) {
    mexLocalFunctionTable save_local_function_table_
      = mclSetCurrentLocalFunctionTable(&_local_function_table_recarga_2_3);
    mclCopyArray(&hObject);
    mclCopyArray(&eventdata);
    mclCopyArray(&handles);
    mxDestroyArray(handles);
    mxDestroyArray(eventdata);
    mxDestroyArray(hObject);
    mclSetCurrentLocalFunctionTable(save_local_function_table_);
    /*
     * % hObject    handle to RoffDpth (see GCBO)
     * % eventdata  reserved - to be defined in a future version of MATLAB
     * % handles    structure with handles and user data (see GUIDATA)
     * 
     * % Hints: get(hObject,'String') returns contents of RoffDpth as text
     * %        str2double(get(hObject,'String')) returns contents of RoffDpth as a double
     * 
     * 
     * % --- Executes during object creation, after setting all properties.
     */
}

/*
 * The function "Mrecarga_2_3_RchrgDpth_CreateFcn" is the implementation
 * version of the "recarga_2_3/RchrgDpth_CreateFcn" M-function from file
 * "u:\final_recarga6\recarga\recarga_2_3.m" (lines 627-642). It contains the
 * actual compiled code for that M-function. It is a static function and must
 * only be called from one of the interface functions, appearing below.
 */
/*
 * function RchrgDpth_CreateFcn(hObject, eventdata, handles)
 */
static void Mrecarga_2_3_RchrgDpth_CreateFcn(mxArray * hObject,
                                             mxArray * eventdata,
                                             mxArray * handles) {
    mexLocalFunctionTable save_local_function_table_
      = mclSetCurrentLocalFunctionTable(&_local_function_table_recarga_2_3);
    mxArray * ans = NULL;
    mclCopyArray(&hObject);
    mclCopyArray(&eventdata);
    mclCopyArray(&handles);
    /*
     * % hObject    handle to RchrgDpth (see GCBO)
     * % eventdata  reserved - to be defined in a future version of MATLAB
     * % handles    empty - handles not created until after all CreateFcns called
     * 
     * % Hint: edit controls usually have a white background on Windows.
     * %       See ISPC and COMPUTER.
     * if ispc
     */
    if (mlfTobool(mlfIspc())) {
        /*
         * set(hObject,'BackgroundColor','white');
         */
        mclAssignAns(
          &ans,
          mlfNSet(
            0, mclVa(hObject, "hObject"), _mxarray28_, _mxarray30_, NULL));
    /*
     * else
     */
    } else {
        /*
         * set(hObject,'BackgroundColor',get(0,'defaultUicontrolBackgroundColor'));
         */
        mclAssignAns(
          &ans,
          mlfNSet(
            0,
            mclVa(hObject, "hObject"),
            _mxarray28_,
            mlfNGet(1, _mxarray32_, _mxarray33_, NULL),
            NULL));
    /*
     * end
     */
    }
    mxDestroyArray(ans);
    mxDestroyArray(handles);
    mxDestroyArray(eventdata);
    mxDestroyArray(hObject);
    mclSetCurrentLocalFunctionTable(save_local_function_table_);
    /*
     * 
     * 
     * 
     */
}

/*
 * The function "Mrecarga_2_3_RchrgDpth_Callback" is the implementation version
 * of the "recarga_2_3/RchrgDpth_Callback" M-function from file
 * "u:\final_recarga6\recarga\recarga_2_3.m" (lines 642-652). It contains the
 * actual compiled code for that M-function. It is a static function and must
 * only be called from one of the interface functions, appearing below.
 */
/*
 * function RchrgDpth_Callback(hObject, eventdata, handles)
 */
static void Mrecarga_2_3_RchrgDpth_Callback(mxArray * hObject,
                                            mxArray * eventdata,
                                            mxArray * handles) {
    mexLocalFunctionTable save_local_function_table_
      = mclSetCurrentLocalFunctionTable(&_local_function_table_recarga_2_3);
    mclCopyArray(&hObject);
    mclCopyArray(&eventdata);
    mclCopyArray(&handles);
    mxDestroyArray(handles);
    mxDestroyArray(eventdata);
    mxDestroyArray(hObject);
    mclSetCurrentLocalFunctionTable(save_local_function_table_);
    /*
     * % hObject    handle to RchrgDpth (see GCBO)
     * % eventdata  reserved - to be defined in a future version of MATLAB
     * % handles    structure with handles and user data (see GUIDATA)
     * 
     * % Hints: get(hObject,'String') returns contents of RchrgDpth as text
     * %        str2double(get(hObject,'String')) returns contents of RchrgDpth as a double
     * 
     * 
     * % --- Executes during object creation, after setting all properties.
     */
}

/*
 * The function "Mrecarga_2_3_EvapDpth_CreateFcn" is the implementation version
 * of the "recarga_2_3/EvapDpth_CreateFcn" M-function from file
 * "u:\final_recarga6\recarga\recarga_2_3.m" (lines 652-667). It contains the
 * actual compiled code for that M-function. It is a static function and must
 * only be called from one of the interface functions, appearing below.
 */
/*
 * function EvapDpth_CreateFcn(hObject, eventdata, handles)
 */
static void Mrecarga_2_3_EvapDpth_CreateFcn(mxArray * hObject,
                                            mxArray * eventdata,
                                            mxArray * handles) {
    mexLocalFunctionTable save_local_function_table_
      = mclSetCurrentLocalFunctionTable(&_local_function_table_recarga_2_3);
    mxArray * ans = NULL;
    mclCopyArray(&hObject);
    mclCopyArray(&eventdata);
    mclCopyArray(&handles);
    /*
     * % hObject    handle to EvapDpth (see GCBO)
     * % eventdata  reserved - to be defined in a future version of MATLAB
     * % handles    empty - handles not created until after all CreateFcns called
     * 
     * % Hint: edit controls usually have a white background on Windows.
     * %       See ISPC and COMPUTER.
     * if ispc
     */
    if (mlfTobool(mlfIspc())) {
        /*
         * set(hObject,'BackgroundColor','white');
         */
        mclAssignAns(
          &ans,
          mlfNSet(
            0, mclVa(hObject, "hObject"), _mxarray28_, _mxarray30_, NULL));
    /*
     * else
     */
    } else {
        /*
         * set(hObject,'BackgroundColor',get(0,'defaultUicontrolBackgroundColor'));
         */
        mclAssignAns(
          &ans,
          mlfNSet(
            0,
            mclVa(hObject, "hObject"),
            _mxarray28_,
            mlfNGet(1, _mxarray32_, _mxarray33_, NULL),
            NULL));
    /*
     * end
     */
    }
    mxDestroyArray(ans);
    mxDestroyArray(handles);
    mxDestroyArray(eventdata);
    mxDestroyArray(hObject);
    mclSetCurrentLocalFunctionTable(save_local_function_table_);
    /*
     * 
     * 
     * 
     */
}

/*
 * The function "Mrecarga_2_3_EvapDpth_Callback" is the implementation version
 * of the "recarga_2_3/EvapDpth_Callback" M-function from file
 * "u:\final_recarga6\recarga\recarga_2_3.m" (lines 667-677). It contains the
 * actual compiled code for that M-function. It is a static function and must
 * only be called from one of the interface functions, appearing below.
 */
/*
 * function EvapDpth_Callback(hObject, eventdata, handles)
 */
static void Mrecarga_2_3_EvapDpth_Callback(mxArray * hObject,
                                           mxArray * eventdata,
                                           mxArray * handles) {
    mexLocalFunctionTable save_local_function_table_
      = mclSetCurrentLocalFunctionTable(&_local_function_table_recarga_2_3);
    mclCopyArray(&hObject);
    mclCopyArray(&eventdata);
    mclCopyArray(&handles);
    mxDestroyArray(handles);
    mxDestroyArray(eventdata);
    mxDestroyArray(hObject);
    mclSetCurrentLocalFunctionTable(save_local_function_table_);
    /*
     * % hObject    handle to EvapDpth (see GCBO)
     * % eventdata  reserved - to be defined in a future version of MATLAB
     * % handles    structure with handles and user data (see GUIDATA)
     * 
     * % Hints: get(hObject,'String') returns contents of EvapDpth as text
     * %        str2double(get(hObject,'String')) returns contents of EvapDpth as a double
     * 
     * 
     * % --- Executes during object creation, after setting all properties.
     */
}

/*
 * The function "Mrecarga_2_3_RnOnDpth_CreateFcn" is the implementation version
 * of the "recarga_2_3/RnOnDpth_CreateFcn" M-function from file
 * "u:\final_recarga6\recarga\recarga_2_3.m" (lines 677-692). It contains the
 * actual compiled code for that M-function. It is a static function and must
 * only be called from one of the interface functions, appearing below.
 */
/*
 * function RnOnDpth_CreateFcn(hObject, eventdata, handles)
 */
static void Mrecarga_2_3_RnOnDpth_CreateFcn(mxArray * hObject,
                                            mxArray * eventdata,
                                            mxArray * handles) {
    mexLocalFunctionTable save_local_function_table_
      = mclSetCurrentLocalFunctionTable(&_local_function_table_recarga_2_3);
    mxArray * ans = NULL;
    mclCopyArray(&hObject);
    mclCopyArray(&eventdata);
    mclCopyArray(&handles);
    /*
     * % hObject    handle to RnOnDpth (see GCBO)
     * % eventdata  reserved - to be defined in a future version of MATLAB
     * % handles    empty - handles not created until after all CreateFcns called
     * 
     * % Hint: edit controls usually have a white background on Windows.
     * %       See ISPC and COMPUTER.
     * if ispc
     */
    if (mlfTobool(mlfIspc())) {
        /*
         * set(hObject,'BackgroundColor','white');
         */
        mclAssignAns(
          &ans,
          mlfNSet(
            0, mclVa(hObject, "hObject"), _mxarray28_, _mxarray30_, NULL));
    /*
     * else
     */
    } else {
        /*
         * set(hObject,'BackgroundColor',get(0,'defaultUicontrolBackgroundColor'));
         */
        mclAssignAns(
          &ans,
          mlfNSet(
            0,
            mclVa(hObject, "hObject"),
            _mxarray28_,
            mlfNGet(1, _mxarray32_, _mxarray33_, NULL),
            NULL));
    /*
     * end
     */
    }
    mxDestroyArray(ans);
    mxDestroyArray(handles);
    mxDestroyArray(eventdata);
    mxDestroyArray(hObject);
    mclSetCurrentLocalFunctionTable(save_local_function_table_);
    /*
     * 
     * 
     * 
     */
}

/*
 * The function "Mrecarga_2_3_RnOnDpth_Callback" is the implementation version
 * of the "recarga_2_3/RnOnDpth_Callback" M-function from file
 * "u:\final_recarga6\recarga\recarga_2_3.m" (lines 692-702). It contains the
 * actual compiled code for that M-function. It is a static function and must
 * only be called from one of the interface functions, appearing below.
 */
/*
 * function RnOnDpth_Callback(hObject, eventdata, handles)
 */
static void Mrecarga_2_3_RnOnDpth_Callback(mxArray * hObject,
                                           mxArray * eventdata,
                                           mxArray * handles) {
    mexLocalFunctionTable save_local_function_table_
      = mclSetCurrentLocalFunctionTable(&_local_function_table_recarga_2_3);
    mclCopyArray(&hObject);
    mclCopyArray(&eventdata);
    mclCopyArray(&handles);
    mxDestroyArray(handles);
    mxDestroyArray(eventdata);
    mxDestroyArray(hObject);
    mclSetCurrentLocalFunctionTable(save_local_function_table_);
    /*
     * % hObject    handle to RnOnDpth (see GCBO)
     * % eventdata  reserved - to be defined in a future version of MATLAB
     * % handles    structure with handles and user data (see GUIDATA)
     * 
     * % Hints: get(hObject,'String') returns contents of RnOnDpth as text
     * %        str2double(get(hObject,'String')) returns contents of RnOnDpth as a double
     * 
     * 
     * % --- Executes during object creation, after setting all properties.
     */
}

/*
 * The function "Mrecarga_2_3_UdVol_CreateFcn" is the implementation version of
 * the "recarga_2_3/UdVol_CreateFcn" M-function from file
 * "u:\final_recarga6\recarga\recarga_2_3.m" (lines 702-717). It contains the
 * actual compiled code for that M-function. It is a static function and must
 * only be called from one of the interface functions, appearing below.
 */
/*
 * function UdVol_CreateFcn(hObject, eventdata, handles)
 */
static void Mrecarga_2_3_UdVol_CreateFcn(mxArray * hObject,
                                         mxArray * eventdata,
                                         mxArray * handles) {
    mexLocalFunctionTable save_local_function_table_
      = mclSetCurrentLocalFunctionTable(&_local_function_table_recarga_2_3);
    mxArray * ans = NULL;
    mclCopyArray(&hObject);
    mclCopyArray(&eventdata);
    mclCopyArray(&handles);
    /*
     * % hObject    handle to UdVol (see GCBO)
     * % eventdata  reserved - to be defined in a future version of MATLAB
     * % handles    empty - handles not created until after all CreateFcns called
     * 
     * % Hint: edit controls usually have a white background on Windows.
     * %       See ISPC and COMPUTER.
     * if ispc
     */
    if (mlfTobool(mlfIspc())) {
        /*
         * set(hObject,'BackgroundColor','white');
         */
        mclAssignAns(
          &ans,
          mlfNSet(
            0, mclVa(hObject, "hObject"), _mxarray28_, _mxarray30_, NULL));
    /*
     * else
     */
    } else {
        /*
         * set(hObject,'BackgroundColor',get(0,'defaultUicontrolBackgroundColor'));
         */
        mclAssignAns(
          &ans,
          mlfNSet(
            0,
            mclVa(hObject, "hObject"),
            _mxarray28_,
            mlfNGet(1, _mxarray32_, _mxarray33_, NULL),
            NULL));
    /*
     * end
     */
    }
    mxDestroyArray(ans);
    mxDestroyArray(handles);
    mxDestroyArray(eventdata);
    mxDestroyArray(hObject);
    mclSetCurrentLocalFunctionTable(save_local_function_table_);
    /*
     * 
     * 
     * 
     */
}

/*
 * The function "Mrecarga_2_3_UdVol_Callback" is the implementation version of
 * the "recarga_2_3/UdVol_Callback" M-function from file
 * "u:\final_recarga6\recarga\recarga_2_3.m" (lines 717-727). It contains the
 * actual compiled code for that M-function. It is a static function and must
 * only be called from one of the interface functions, appearing below.
 */
/*
 * function UdVol_Callback(hObject, eventdata, handles)
 */
static void Mrecarga_2_3_UdVol_Callback(mxArray * hObject,
                                        mxArray * eventdata,
                                        mxArray * handles) {
    mexLocalFunctionTable save_local_function_table_
      = mclSetCurrentLocalFunctionTable(&_local_function_table_recarga_2_3);
    mclCopyArray(&hObject);
    mclCopyArray(&eventdata);
    mclCopyArray(&handles);
    mxDestroyArray(handles);
    mxDestroyArray(eventdata);
    mxDestroyArray(hObject);
    mclSetCurrentLocalFunctionTable(save_local_function_table_);
    /*
     * % hObject    handle to UdVol (see GCBO)
     * % eventdata  reserved - to be defined in a future version of MATLAB
     * % handles    structure with handles and user data (see GUIDATA)
     * 
     * % Hints: get(hObject,'String') returns contents of UdVol as text
     * %        str2double(get(hObject,'String')) returns contents of UdVol as a double
     * 
     * 
     * % --- Executes during object creation, after setting all properties.
     */
}

/*
 * The function "Mrecarga_2_3_UdFrac_CreateFcn" is the implementation version
 * of the "recarga_2_3/UdFrac_CreateFcn" M-function from file
 * "u:\final_recarga6\recarga\recarga_2_3.m" (lines 727-742). It contains the
 * actual compiled code for that M-function. It is a static function and must
 * only be called from one of the interface functions, appearing below.
 */
/*
 * function UdFrac_CreateFcn(hObject, eventdata, handles)
 */
static void Mrecarga_2_3_UdFrac_CreateFcn(mxArray * hObject,
                                          mxArray * eventdata,
                                          mxArray * handles) {
    mexLocalFunctionTable save_local_function_table_
      = mclSetCurrentLocalFunctionTable(&_local_function_table_recarga_2_3);
    mxArray * ans = NULL;
    mclCopyArray(&hObject);
    mclCopyArray(&eventdata);
    mclCopyArray(&handles);
    /*
     * % hObject    handle to UdFrac (see GCBO)
     * % eventdata  reserved - to be defined in a future version of MATLAB
     * % handles    empty - handles not created until after all CreateFcns called
     * 
     * % Hint: edit controls usually have a white background on Windows.
     * %       See ISPC and COMPUTER.
     * if ispc
     */
    if (mlfTobool(mlfIspc())) {
        /*
         * set(hObject,'BackgroundColor','white');
         */
        mclAssignAns(
          &ans,
          mlfNSet(
            0, mclVa(hObject, "hObject"), _mxarray28_, _mxarray30_, NULL));
    /*
     * else
     */
    } else {
        /*
         * set(hObject,'BackgroundColor',get(0,'defaultUicontrolBackgroundColor'));
         */
        mclAssignAns(
          &ans,
          mlfNSet(
            0,
            mclVa(hObject, "hObject"),
            _mxarray28_,
            mlfNGet(1, _mxarray32_, _mxarray33_, NULL),
            NULL));
    /*
     * end
     */
    }
    mxDestroyArray(ans);
    mxDestroyArray(handles);
    mxDestroyArray(eventdata);
    mxDestroyArray(hObject);
    mclSetCurrentLocalFunctionTable(save_local_function_table_);
    /*
     * 
     * 
     * 
     */
}

/*
 * The function "Mrecarga_2_3_UdFrac_Callback" is the implementation version of
 * the "recarga_2_3/UdFrac_Callback" M-function from file
 * "u:\final_recarga6\recarga\recarga_2_3.m" (lines 742-752). It contains the
 * actual compiled code for that M-function. It is a static function and must
 * only be called from one of the interface functions, appearing below.
 */
/*
 * function UdFrac_Callback(hObject, eventdata, handles)
 */
static void Mrecarga_2_3_UdFrac_Callback(mxArray * hObject,
                                         mxArray * eventdata,
                                         mxArray * handles) {
    mexLocalFunctionTable save_local_function_table_
      = mclSetCurrentLocalFunctionTable(&_local_function_table_recarga_2_3);
    mclCopyArray(&hObject);
    mclCopyArray(&eventdata);
    mclCopyArray(&handles);
    mxDestroyArray(handles);
    mxDestroyArray(eventdata);
    mxDestroyArray(hObject);
    mclSetCurrentLocalFunctionTable(save_local_function_table_);
    /*
     * % hObject    handle to UdFrac (see GCBO)
     * % eventdata  reserved - to be defined in a future version of MATLAB
     * % handles    structure with handles and user data (see GUIDATA)
     * 
     * % Hints: get(hObject,'String') returns contents of UdFrac as text
     * %        str2double(get(hObject,'String')) returns contents of UdFrac as a double
     * 
     * 
     * % --- Executes during object creation, after setting all properties.
     */
}

/*
 * The function "Mrecarga_2_3_UdDpth_CreateFcn" is the implementation version
 * of the "recarga_2_3/UdDpth_CreateFcn" M-function from file
 * "u:\final_recarga6\recarga\recarga_2_3.m" (lines 752-767). It contains the
 * actual compiled code for that M-function. It is a static function and must
 * only be called from one of the interface functions, appearing below.
 */
/*
 * function UdDpth_CreateFcn(hObject, eventdata, handles)
 */
static void Mrecarga_2_3_UdDpth_CreateFcn(mxArray * hObject,
                                          mxArray * eventdata,
                                          mxArray * handles) {
    mexLocalFunctionTable save_local_function_table_
      = mclSetCurrentLocalFunctionTable(&_local_function_table_recarga_2_3);
    mxArray * ans = NULL;
    mclCopyArray(&hObject);
    mclCopyArray(&eventdata);
    mclCopyArray(&handles);
    /*
     * % hObject    handle to UdDpth (see GCBO)
     * % eventdata  reserved - to be defined in a future version of MATLAB
     * % handles    empty - handles not created until after all CreateFcns called
     * 
     * % Hint: edit controls usually have a white background on Windows.
     * %       See ISPC and COMPUTER.
     * if ispc
     */
    if (mlfTobool(mlfIspc())) {
        /*
         * set(hObject,'BackgroundColor','white');
         */
        mclAssignAns(
          &ans,
          mlfNSet(
            0, mclVa(hObject, "hObject"), _mxarray28_, _mxarray30_, NULL));
    /*
     * else
     */
    } else {
        /*
         * set(hObject,'BackgroundColor',get(0,'defaultUicontrolBackgroundColor'));
         */
        mclAssignAns(
          &ans,
          mlfNSet(
            0,
            mclVa(hObject, "hObject"),
            _mxarray28_,
            mlfNGet(1, _mxarray32_, _mxarray33_, NULL),
            NULL));
    /*
     * end
     */
    }
    mxDestroyArray(ans);
    mxDestroyArray(handles);
    mxDestroyArray(eventdata);
    mxDestroyArray(hObject);
    mclSetCurrentLocalFunctionTable(save_local_function_table_);
    /*
     * 
     * 
     * 
     */
}

/*
 * The function "Mrecarga_2_3_UdDpth_Callback" is the implementation version of
 * the "recarga_2_3/UdDpth_Callback" M-function from file
 * "u:\final_recarga6\recarga\recarga_2_3.m" (lines 767-777). It contains the
 * actual compiled code for that M-function. It is a static function and must
 * only be called from one of the interface functions, appearing below.
 */
/*
 * function UdDpth_Callback(hObject, eventdata, handles)
 */
static void Mrecarga_2_3_UdDpth_Callback(mxArray * hObject,
                                         mxArray * eventdata,
                                         mxArray * handles) {
    mexLocalFunctionTable save_local_function_table_
      = mclSetCurrentLocalFunctionTable(&_local_function_table_recarga_2_3);
    mclCopyArray(&hObject);
    mclCopyArray(&eventdata);
    mclCopyArray(&handles);
    mxDestroyArray(handles);
    mxDestroyArray(eventdata);
    mxDestroyArray(hObject);
    mclSetCurrentLocalFunctionTable(save_local_function_table_);
    /*
     * % hObject    handle to UdDpth (see GCBO)
     * % eventdata  reserved - to be defined in a future version of MATLAB
     * % handles    structure with handles and user data (see GUIDATA)
     * 
     * % Hints: get(hObject,'String') returns contents of UdDpth as text
     * %        str2double(get(hObject,'String')) returns contents of UdDpth as a double
     * 
     * 
     * % --- Executes during object creation, after setting all properties.
     */
}

/*
 * The function "Mrecarga_2_3_UFlow_CreateFcn" is the implementation version of
 * the "recarga_2_3/UFlow_CreateFcn" M-function from file
 * "u:\final_recarga6\recarga\recarga_2_3.m" (lines 777-792). It contains the
 * actual compiled code for that M-function. It is a static function and must
 * only be called from one of the interface functions, appearing below.
 */
/*
 * function UFlow_CreateFcn(hObject, eventdata, handles)
 */
static void Mrecarga_2_3_UFlow_CreateFcn(mxArray * hObject,
                                         mxArray * eventdata,
                                         mxArray * handles) {
    mexLocalFunctionTable save_local_function_table_
      = mclSetCurrentLocalFunctionTable(&_local_function_table_recarga_2_3);
    mxArray * ans = NULL;
    mclCopyArray(&hObject);
    mclCopyArray(&eventdata);
    mclCopyArray(&handles);
    /*
     * % hObject    handle to UFlow (see GCBO)
     * % eventdata  reserved - to be defined in a future version of MATLAB
     * % handles    empty - handles not created until after all CreateFcns called
     * 
     * % Hint: edit controls usually have a white background on Windows.
     * %       See ISPC and COMPUTER.
     * if ispc
     */
    if (mlfTobool(mlfIspc())) {
        /*
         * set(hObject,'BackgroundColor','white');
         */
        mclAssignAns(
          &ans,
          mlfNSet(
            0, mclVa(hObject, "hObject"), _mxarray28_, _mxarray30_, NULL));
    /*
     * else
     */
    } else {
        /*
         * set(hObject,'BackgroundColor',get(0,'defaultUicontrolBackgroundColor'));
         */
        mclAssignAns(
          &ans,
          mlfNSet(
            0,
            mclVa(hObject, "hObject"),
            _mxarray28_,
            mlfNGet(1, _mxarray32_, _mxarray33_, NULL),
            NULL));
    /*
     * end
     */
    }
    mxDestroyArray(ans);
    mxDestroyArray(handles);
    mxDestroyArray(eventdata);
    mxDestroyArray(hObject);
    mclSetCurrentLocalFunctionTable(save_local_function_table_);
    /*
     * 
     * 
     * 
     */
}

/*
 * The function "Mrecarga_2_3_UFlow_Callback" is the implementation version of
 * the "recarga_2_3/UFlow_Callback" M-function from file
 * "u:\final_recarga6\recarga\recarga_2_3.m" (lines 792-823). It contains the
 * actual compiled code for that M-function. It is a static function and must
 * only be called from one of the interface functions, appearing below.
 */
/*
 * function UFlow_Callback(hObject, eventdata, handles)
 */
static void Mrecarga_2_3_UFlow_Callback(mxArray * hObject,
                                        mxArray * eventdata,
                                        mxArray * handles) {
    mexLocalFunctionTable save_local_function_table_
      = mclSetCurrentLocalFunctionTable(&_local_function_table_recarga_2_3);
    mxArray * ans = NULL;
    mxArray * unit = NULL;
    mxArray * udiam = NULL;
    mxArray * pi = NULL;
    mxArray * g = NULL;
    mxArray * Co = NULL;
    mxArray * hmax = NULL;
    mxArray * Umax = NULL;
    mxArray * UD_Flow = NULL;
    mxArray * Srz = NULL;
    mxArray * dmin = NULL;
    mxArray * Arg = NULL;
    mclCopyArray(&hObject);
    mclCopyArray(&eventdata);
    mclCopyArray(&handles);
    /*
     * % hObject    handle to UFlow (see GCBO)
     * % eventdata  reserved - to be defined in a future version of MATLAB
     * % handles    structure with handles and user data (see GUIDATA)
     * 
     * % Hints: get(hObject,'String') returns contents of UFlow as text
     * %        str2double(get(hObject,'String')) returns contents of UFlow as a double
     * 
     * %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
     * %Determine underdrain size
     * %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
     * Arg = str2num(get(handles.RGArea,'String'));  %Bioretention Cell Size 
     */
    mlfAssign(
      &Arg,
      mlfStr2num(
        NULL,
        mlfNGet(
          1,
          mlfIndexRef(mclVa(handles, "handles"), ".RGArea"),
          _mxarray35_,
          NULL)));
    /*
     * dmin = str2num(get(handles.Sd,'String'));
     */
    mlfAssign(
      &dmin,
      mlfStr2num(
        NULL,
        mlfNGet(
          1,
          mlfIndexRef(mclVa(handles, "handles"), ".Sd"), _mxarray35_, NULL)));
    /*
     * Srz = str2num(get(handles.Srz,'String'));
     */
    mlfAssign(
      &Srz,
      mlfStr2num(
        NULL,
        mlfNGet(
          1,
          mlfIndexRef(mclVa(handles, "handles"), ".Srz"), _mxarray35_, NULL)));
    /*
     * UD_Flow = str2double(get(hObject,'String'));
     */
    mlfAssign(
      &UD_Flow,
      mlfStr2double(mlfNGet(1, mclVa(hObject, "hObject"), _mxarray35_, NULL)));
    /*
     * Umax = (UD_Flow/100)*(Arg/3600); %Max. Underdrain flow [m3/sec]
     */
    mlfAssign(
      &Umax,
      mclMtimes(
        mclMrdivide(mclVv(UD_Flow, "UD_Flow"), _mxarray37_),
        mclMrdivide(mclVv(Arg, "Arg"), _mxarray38_)));
    /*
     * hmax = (dmin + Srz)/100;  %Max. Head on underdrain [m]
     */
    mlfAssign(
      &hmax,
      mclMrdivide(
        mclPlus(mclVv(dmin, "dmin"), mclVv(Srz, "Srz")), _mxarray37_));
    /*
     * Co = 0.62; g=9.81; pi=3.1457; %constants
     */
    mlfAssign(&Co, _mxarray39_);
    mlfAssign(&g, _mxarray40_);
    mlfAssign(&pi, _mxarray41_);
    /*
     * udiam = 2*sqrt((Umax/(Co*pi*sqrt(2*g*hmax))))*1000;  %underdrain diameter [m]
     */
    mlfAssign(
      &udiam,
      mclMtimes(
        mclMtimes(
          _mxarray42_,
          mlfSqrt(
            mclMrdivide(
              mclVv(Umax, "Umax"),
              mclMtimes(
                mclMtimes(mclVv(Co, "Co"), mclVv(pi, "pi")),
                mlfSqrt(
                  mclMtimes(
                    mclMtimes(_mxarray42_, mclVv(g, "g")),
                    mclVv(hmax, "hmax"))))))),
        _mxarray43_));
    /*
     * unit = get(handles.Units,'Value');
     */
    mlfAssign(
      &unit,
      mlfNGet(
        1,
        mlfIndexRef(mclVa(handles, "handles"), ".Units"), _mxarray44_, NULL));
    /*
     * if unit == 2
     */
    if (mclEqBool(mclVv(unit, "unit"), _mxarray42_)) {
        /*
         * g = 32.18503937007874015748031496063;
         */
        mlfAssign(&g, _mxarray46_);
        /*
         * hmax = (dmin + Srz)/12; %Max. Head on underdrain [ft]
         */
        mlfAssign(
          &hmax,
          mclMrdivide(
            mclPlus(mclVv(dmin, "dmin"), mclVv(Srz, "Srz")), _mxarray47_));
        /*
         * Umax = (UD_Flow/12)*(Arg/3600); %Max. Underdrain flow [ft3/sec]
         */
        mlfAssign(
          &Umax,
          mclMtimes(
            mclMrdivide(mclVv(UD_Flow, "UD_Flow"), _mxarray47_),
            mclMrdivide(mclVv(Arg, "Arg"), _mxarray38_)));
        /*
         * udiam = 2*sqrt((Umax/(Co*pi*sqrt(2*g*hmax))))*12;  %underdrain diameter [ft]
         */
        mlfAssign(
          &udiam,
          mclMtimes(
            mclMtimes(
              _mxarray42_,
              mlfSqrt(
                mclMrdivide(
                  mclVv(Umax, "Umax"),
                  mclMtimes(
                    mclMtimes(mclVv(Co, "Co"), mclVv(pi, "pi")),
                    mlfSqrt(
                      mclMtimes(
                        mclMtimes(_mxarray42_, mclVv(g, "g")),
                        mclVv(hmax, "hmax"))))))),
            _mxarray47_));
    /*
     * end
     */
    }
    /*
     * 
     * set(handles.Udiam,'String',num2str(udiam));  %display resultant underdrain diam in figure
     */
    mclAssignAns(
      &ans,
      mlfNSet(
        0,
        mlfIndexRef(mclVa(handles, "handles"), ".Udiam"),
        _mxarray35_,
        mlfNum2str(mclVv(udiam, "udiam"), NULL),
        NULL));
    mxDestroyArray(Arg);
    mxDestroyArray(dmin);
    mxDestroyArray(Srz);
    mxDestroyArray(UD_Flow);
    mxDestroyArray(Umax);
    mxDestroyArray(hmax);
    mxDestroyArray(Co);
    mxDestroyArray(g);
    mxDestroyArray(pi);
    mxDestroyArray(udiam);
    mxDestroyArray(unit);
    mxDestroyArray(ans);
    mxDestroyArray(handles);
    mxDestroyArray(eventdata);
    mxDestroyArray(hObject);
    mclSetCurrentLocalFunctionTable(save_local_function_table_);
    /*
     * 
     * 
     * % --- Executes during object creation, after setting all properties.
     */
}

/*
 * The function "Mrecarga_2_3_BasinArea_CreateFcn" is the implementation
 * version of the "recarga_2_3/BasinArea_CreateFcn" M-function from file
 * "u:\final_recarga6\recarga\recarga_2_3.m" (lines 823-838). It contains the
 * actual compiled code for that M-function. It is a static function and must
 * only be called from one of the interface functions, appearing below.
 */
/*
 * function BasinArea_CreateFcn(hObject, eventdata, handles)
 */
static void Mrecarga_2_3_BasinArea_CreateFcn(mxArray * hObject,
                                             mxArray * eventdata,
                                             mxArray * handles) {
    mexLocalFunctionTable save_local_function_table_
      = mclSetCurrentLocalFunctionTable(&_local_function_table_recarga_2_3);
    mxArray * ans = NULL;
    mclCopyArray(&hObject);
    mclCopyArray(&eventdata);
    mclCopyArray(&handles);
    /*
     * % hObject    handle to BasinArea (see GCBO)
     * % eventdata  reserved - to be defined in a future version of MATLAB
     * % handles    empty - handles not created until after all CreateFcns called
     * 
     * % Hint: edit controls usually have a white background on Windows.
     * %       See ISPC and COMPUTER.
     * if ispc
     */
    if (mlfTobool(mlfIspc())) {
        /*
         * set(hObject,'BackgroundColor','white');
         */
        mclAssignAns(
          &ans,
          mlfNSet(
            0, mclVa(hObject, "hObject"), _mxarray28_, _mxarray30_, NULL));
    /*
     * else
     */
    } else {
        /*
         * set(hObject,'BackgroundColor',get(0,'defaultUicontrolBackgroundColor'));
         */
        mclAssignAns(
          &ans,
          mlfNSet(
            0,
            mclVa(hObject, "hObject"),
            _mxarray28_,
            mlfNGet(1, _mxarray32_, _mxarray33_, NULL),
            NULL));
    /*
     * end
     */
    }
    mxDestroyArray(ans);
    mxDestroyArray(handles);
    mxDestroyArray(eventdata);
    mxDestroyArray(hObject);
    mclSetCurrentLocalFunctionTable(save_local_function_table_);
    /*
     * 
     * 
     * 
     */
}

/*
 * The function "Mrecarga_2_3_BasinArea_Callback" is the implementation version
 * of the "recarga_2_3/BasinArea_Callback" M-function from file
 * "u:\final_recarga6\recarga\recarga_2_3.m" (lines 838-848). It contains the
 * actual compiled code for that M-function. It is a static function and must
 * only be called from one of the interface functions, appearing below.
 */
/*
 * function BasinArea_Callback(hObject, eventdata, handles)
 */
static void Mrecarga_2_3_BasinArea_Callback(mxArray * hObject,
                                            mxArray * eventdata,
                                            mxArray * handles) {
    mexLocalFunctionTable save_local_function_table_
      = mclSetCurrentLocalFunctionTable(&_local_function_table_recarga_2_3);
    mclCopyArray(&hObject);
    mclCopyArray(&eventdata);
    mclCopyArray(&handles);
    mxDestroyArray(handles);
    mxDestroyArray(eventdata);
    mxDestroyArray(hObject);
    mclSetCurrentLocalFunctionTable(save_local_function_table_);
    /*
     * % hObject    handle to BasinArea (see GCBO)
     * % eventdata  reserved - to be defined in a future version of MATLAB
     * % handles    structure with handles and user data (see GUIDATA)
     * 
     * % Hints: get(hObject,'String') returns contents of BasinArea as text
     * %        str2double(get(hObject,'String')) returns contents of BasinArea as a double
     * 
     * 
     * % --- Executes during object creation, after setting all properties.
     */
}

/*
 * The function "Mrecarga_2_3_Udiam_CreateFcn" is the implementation version of
 * the "recarga_2_3/Udiam_CreateFcn" M-function from file
 * "u:\final_recarga6\recarga\recarga_2_3.m" (lines 848-863). It contains the
 * actual compiled code for that M-function. It is a static function and must
 * only be called from one of the interface functions, appearing below.
 */
/*
 * function Udiam_CreateFcn(hObject, eventdata, handles)
 */
static void Mrecarga_2_3_Udiam_CreateFcn(mxArray * hObject,
                                         mxArray * eventdata,
                                         mxArray * handles) {
    mexLocalFunctionTable save_local_function_table_
      = mclSetCurrentLocalFunctionTable(&_local_function_table_recarga_2_3);
    mxArray * ans = NULL;
    mclCopyArray(&hObject);
    mclCopyArray(&eventdata);
    mclCopyArray(&handles);
    /*
     * % hObject    handle to Udiam (see GCBO)
     * % eventdata  reserved - to be defined in a future version of MATLAB
     * % handles    empty - handles not created until after all CreateFcns called
     * 
     * % Hint: edit controls usually have a white background on Windows.
     * %       See ISPC and COMPUTER.
     * if ispc
     */
    if (mlfTobool(mlfIspc())) {
        /*
         * set(hObject,'BackgroundColor','white');
         */
        mclAssignAns(
          &ans,
          mlfNSet(
            0, mclVa(hObject, "hObject"), _mxarray28_, _mxarray30_, NULL));
    /*
     * else
     */
    } else {
        /*
         * set(hObject,'BackgroundColor',get(0,'defaultUicontrolBackgroundColor'));
         */
        mclAssignAns(
          &ans,
          mlfNSet(
            0,
            mclVa(hObject, "hObject"),
            _mxarray28_,
            mlfNGet(1, _mxarray32_, _mxarray33_, NULL),
            NULL));
    /*
     * end
     */
    }
    mxDestroyArray(ans);
    mxDestroyArray(handles);
    mxDestroyArray(eventdata);
    mxDestroyArray(hObject);
    mclSetCurrentLocalFunctionTable(save_local_function_table_);
    /*
     * 
     * 
     * 
     */
}

/*
 * The function "Mrecarga_2_3_Udiam_Callback" is the implementation version of
 * the "recarga_2_3/Udiam_Callback" M-function from file
 * "u:\final_recarga6\recarga\recarga_2_3.m" (lines 863-894). It contains the
 * actual compiled code for that M-function. It is a static function and must
 * only be called from one of the interface functions, appearing below.
 */
/*
 * function Udiam_Callback(hObject, eventdata, handles)
 */
static void Mrecarga_2_3_Udiam_Callback(mxArray * hObject,
                                        mxArray * eventdata,
                                        mxArray * handles) {
    mexLocalFunctionTable save_local_function_table_
      = mclSetCurrentLocalFunctionTable(&_local_function_table_recarga_2_3);
    mxArray * ans = NULL;
    mxArray * unit = NULL;
    mxArray * UD_Flow = NULL;
    mxArray * Umax = NULL;
    mxArray * Uarea = NULL;
    mxArray * pi = NULL;
    mxArray * g = NULL;
    mxArray * Co = NULL;
    mxArray * hmax = NULL;
    mxArray * Diam = NULL;
    mxArray * Srz = NULL;
    mxArray * dmin = NULL;
    mxArray * Arg = NULL;
    mclCopyArray(&hObject);
    mclCopyArray(&eventdata);
    mclCopyArray(&handles);
    /*
     * % hObject    handle to Udiam (see GCBO)
     * % eventdata  reserved - to be defined in a future version of MATLAB
     * % handles    structure with handles and user data (see GUIDATA)
     * 
     * % Hints: get(hObject,'String') returns contents of Udiam as text
     * %        str2double(get(hObject,'String')) returns contents of Udiam as a double
     * 
     * 
     * % --- Executes on button press in clear.
     * Arg = str2num(get(handles.RGArea,'String'));  %Bioretention Cell Size 
     */
    mlfAssign(
      &Arg,
      mlfStr2num(
        NULL,
        mlfNGet(
          1,
          mlfIndexRef(mclVa(handles, "handles"), ".RGArea"),
          _mxarray35_,
          NULL)));
    /*
     * dmin = str2num(get(handles.Sd,'String'));
     */
    mlfAssign(
      &dmin,
      mlfStr2num(
        NULL,
        mlfNGet(
          1,
          mlfIndexRef(mclVa(handles, "handles"), ".Sd"), _mxarray35_, NULL)));
    /*
     * Srz = str2num(get(handles.Srz,'String'));
     */
    mlfAssign(
      &Srz,
      mlfStr2num(
        NULL,
        mlfNGet(
          1,
          mlfIndexRef(mclVa(handles, "handles"), ".Srz"), _mxarray35_, NULL)));
    /*
     * Diam = str2num(get(hObject,'String'));
     */
    mlfAssign(
      &Diam,
      mlfStr2num(
        NULL, mlfNGet(1, mclVa(hObject, "hObject"), _mxarray35_, NULL)));
    /*
     * hmax = (dmin + Srz)/100;  %Max. Head on underdrain [m]
     */
    mlfAssign(
      &hmax,
      mclMrdivide(
        mclPlus(mclVv(dmin, "dmin"), mclVv(Srz, "Srz")), _mxarray37_));
    /*
     * Co = 0.62; g=9.81; pi=3.1457; %constants
     */
    mlfAssign(&Co, _mxarray39_);
    mlfAssign(&g, _mxarray40_);
    mlfAssign(&pi, _mxarray41_);
    /*
     * Uarea = pi*(Diam/2000)^2;  %underdrain area [m]
     */
    mlfAssign(
      &Uarea,
      mclMtimes(
        mclVv(pi, "pi"),
        mclMpower(mclMrdivide(mclVv(Diam, "Diam"), _mxarray48_), _mxarray42_)));
    /*
     * Umax = sqrt(2*g*hmax)*Co*Uarea;  %Max. Underdrain flow [m3/sec]
     */
    mlfAssign(
      &Umax,
      mclMtimes(
        mclMtimes(
          mlfSqrt(
            mclMtimes(
              mclMtimes(_mxarray42_, mclVv(g, "g")), mclVv(hmax, "hmax"))),
          mclVv(Co, "Co")),
        mclVv(Uarea, "Uarea")));
    /*
     * UD_Flow = Umax/(Arg/3600)*100;
     */
    mlfAssign(
      &UD_Flow,
      mclMtimes(
        mclMrdivide(
          mclVv(Umax, "Umax"), mclMrdivide(mclVv(Arg, "Arg"), _mxarray38_)),
        _mxarray37_));
    /*
     * unit = get(handles.Units,'Value');
     */
    mlfAssign(
      &unit,
      mlfNGet(
        1,
        mlfIndexRef(mclVa(handles, "handles"), ".Units"), _mxarray44_, NULL));
    /*
     * if unit == 2
     */
    if (mclEqBool(mclVv(unit, "unit"), _mxarray42_)) {
        /*
         * g = 32.18503937007874015748031496063;
         */
        mlfAssign(&g, _mxarray46_);
        /*
         * hmax = (dmin + Srz)/12; %Max. Head on underdrain [ft]
         */
        mlfAssign(
          &hmax,
          mclMrdivide(
            mclPlus(mclVv(dmin, "dmin"), mclVv(Srz, "Srz")), _mxarray47_));
        /*
         * Uarea = pi*(Diam/24)^2; 
         */
        mlfAssign(
          &Uarea,
          mclMtimes(
            mclVv(pi, "pi"),
            mclMpower(
              mclMrdivide(mclVv(Diam, "Diam"), _mxarray49_), _mxarray42_)));
        /*
         * Umax = sqrt(2*g*hmax)*Co*Uarea; %Max. Underdrain flow [ft3/sec]
         */
        mlfAssign(
          &Umax,
          mclMtimes(
            mclMtimes(
              mlfSqrt(
                mclMtimes(
                  mclMtimes(_mxarray42_, mclVv(g, "g")), mclVv(hmax, "hmax"))),
              mclVv(Co, "Co")),
            mclVv(Uarea, "Uarea")));
        /*
         * UD_Flow = Umax/(Arg/3600)*12; 
         */
        mlfAssign(
          &UD_Flow,
          mclMtimes(
            mclMrdivide(
              mclVv(Umax, "Umax"), mclMrdivide(mclVv(Arg, "Arg"), _mxarray38_)),
            _mxarray47_));
    /*
     * end
     */
    }
    /*
     * 
     * set(handles.UFlow,'String',num2str(UD_Flow));  %display resultant underdrain diam in figure
     */
    mclAssignAns(
      &ans,
      mlfNSet(
        0,
        mlfIndexRef(mclVa(handles, "handles"), ".UFlow"),
        _mxarray35_,
        mlfNum2str(mclVv(UD_Flow, "UD_Flow"), NULL),
        NULL));
    mxDestroyArray(Arg);
    mxDestroyArray(dmin);
    mxDestroyArray(Srz);
    mxDestroyArray(Diam);
    mxDestroyArray(hmax);
    mxDestroyArray(Co);
    mxDestroyArray(g);
    mxDestroyArray(pi);
    mxDestroyArray(Uarea);
    mxDestroyArray(Umax);
    mxDestroyArray(UD_Flow);
    mxDestroyArray(unit);
    mxDestroyArray(ans);
    mxDestroyArray(handles);
    mxDestroyArray(eventdata);
    mxDestroyArray(hObject);
    mclSetCurrentLocalFunctionTable(save_local_function_table_);
    /*
     * 
     * % --- Executes during object creation, after setting all properties.
     */
}

/*
 * The function "Mrecarga_2_3_AveET_CreateFcn" is the implementation version of
 * the "recarga_2_3/AveET_CreateFcn" M-function from file
 * "u:\final_recarga6\recarga\recarga_2_3.m" (lines 894-909). It contains the
 * actual compiled code for that M-function. It is a static function and must
 * only be called from one of the interface functions, appearing below.
 */
/*
 * function AveET_CreateFcn(hObject, eventdata, handles)
 */
static void Mrecarga_2_3_AveET_CreateFcn(mxArray * hObject,
                                         mxArray * eventdata,
                                         mxArray * handles) {
    mexLocalFunctionTable save_local_function_table_
      = mclSetCurrentLocalFunctionTable(&_local_function_table_recarga_2_3);
    mxArray * ans = NULL;
    mclCopyArray(&hObject);
    mclCopyArray(&eventdata);
    mclCopyArray(&handles);
    /*
     * % hObject    handle to AveET (see GCBO)
     * % eventdata  reserved - to be defined in a future version of MATLAB
     * % handles    empty - handles not created until after all CreateFcns called
     * 
     * % Hint: edit controls usually have a white background on Windows.
     * %       See ISPC and COMPUTER.
     * if ispc
     */
    if (mlfTobool(mlfIspc())) {
        /*
         * set(hObject,'BackgroundColor','white');
         */
        mclAssignAns(
          &ans,
          mlfNSet(
            0, mclVa(hObject, "hObject"), _mxarray28_, _mxarray30_, NULL));
    /*
     * else
     */
    } else {
        /*
         * set(hObject,'BackgroundColor',get(0,'defaultUicontrolBackgroundColor'));
         */
        mclAssignAns(
          &ans,
          mlfNSet(
            0,
            mclVa(hObject, "hObject"),
            _mxarray28_,
            mlfNGet(1, _mxarray32_, _mxarray33_, NULL),
            NULL));
    /*
     * end
     */
    }
    mxDestroyArray(ans);
    mxDestroyArray(handles);
    mxDestroyArray(eventdata);
    mxDestroyArray(hObject);
    mclSetCurrentLocalFunctionTable(save_local_function_table_);
    /*
     * 
     * 
     * 
     */
}

/*
 * The function "Mrecarga_2_3_AveET_Callback" is the implementation version of
 * the "recarga_2_3/AveET_Callback" M-function from file
 * "u:\final_recarga6\recarga\recarga_2_3.m" (lines 909-922). It contains the
 * actual compiled code for that M-function. It is a static function and must
 * only be called from one of the interface functions, appearing below.
 */
/*
 * function AveET_Callback(hObject, eventdata, handles)
 */
static void Mrecarga_2_3_AveET_Callback(mxArray * hObject,
                                        mxArray * eventdata,
                                        mxArray * handles) {
    mexLocalFunctionTable save_local_function_table_
      = mclSetCurrentLocalFunctionTable(&_local_function_table_recarga_2_3);
    mclCopyArray(&hObject);
    mclCopyArray(&eventdata);
    mclCopyArray(&handles);
    mxDestroyArray(handles);
    mxDestroyArray(eventdata);
    mxDestroyArray(hObject);
    mclSetCurrentLocalFunctionTable(save_local_function_table_);
    /*
     * % hObject    handle to AveET (see GCBO)
     * % eventdata  reserved - to be defined in a future version of MATLAB
     * % handles    structure with handles and user data (see GUIDATA)
     * 
     * % Hints: get(hObject,'String') returns contents of AveET as text
     * %        str2double(get(hObject,'String')) returns contents of AveET as a double
     * 
     * 
     * 
     * 
     * 
     * % --- Executes during object creation, after setting all properties.
     */
}

/*
 * The function "Mrecarga_2_3_Sd_CreateFcn" is the implementation version of
 * the "recarga_2_3/Sd_CreateFcn" M-function from file
 * "u:\final_recarga6\recarga\recarga_2_3.m" (lines 922-937). It contains the
 * actual compiled code for that M-function. It is a static function and must
 * only be called from one of the interface functions, appearing below.
 */
/*
 * function Sd_CreateFcn(hObject, eventdata, handles)
 */
static void Mrecarga_2_3_Sd_CreateFcn(mxArray * hObject,
                                      mxArray * eventdata,
                                      mxArray * handles) {
    mexLocalFunctionTable save_local_function_table_
      = mclSetCurrentLocalFunctionTable(&_local_function_table_recarga_2_3);
    mxArray * ans = NULL;
    mclCopyArray(&hObject);
    mclCopyArray(&eventdata);
    mclCopyArray(&handles);
    /*
     * % hObject    handle to Sd (see GCBO)
     * % eventdata  reserved - to be defined in a future version of MATLAB
     * % handles    empty - handles not created until after all CreateFcns called
     * 
     * % Hint: edit controls usually have a white background on Windows.
     * %       See ISPC and COMPUTER.
     * if ispc
     */
    if (mlfTobool(mlfIspc())) {
        /*
         * set(hObject,'BackgroundColor','white');
         */
        mclAssignAns(
          &ans,
          mlfNSet(
            0, mclVa(hObject, "hObject"), _mxarray28_, _mxarray30_, NULL));
    /*
     * else
     */
    } else {
        /*
         * set(hObject,'BackgroundColor',get(0,'defaultUicontrolBackgroundColor'));
         */
        mclAssignAns(
          &ans,
          mlfNSet(
            0,
            mclVa(hObject, "hObject"),
            _mxarray28_,
            mlfNGet(1, _mxarray32_, _mxarray33_, NULL),
            NULL));
    /*
     * end
     */
    }
    mxDestroyArray(ans);
    mxDestroyArray(handles);
    mxDestroyArray(eventdata);
    mxDestroyArray(hObject);
    mclSetCurrentLocalFunctionTable(save_local_function_table_);
    /*
     * 
     * 
     * 
     */
}

/*
 * The function "Mrecarga_2_3_Sd_Callback" is the implementation version of the
 * "recarga_2_3/Sd_Callback" M-function from file
 * "u:\final_recarga6\recarga\recarga_2_3.m" (lines 937-947). It contains the
 * actual compiled code for that M-function. It is a static function and must
 * only be called from one of the interface functions, appearing below.
 */
/*
 * function Sd_Callback(hObject, eventdata, handles)
 */
static void Mrecarga_2_3_Sd_Callback(mxArray * hObject,
                                     mxArray * eventdata,
                                     mxArray * handles) {
    mexLocalFunctionTable save_local_function_table_
      = mclSetCurrentLocalFunctionTable(&_local_function_table_recarga_2_3);
    mclCopyArray(&hObject);
    mclCopyArray(&eventdata);
    mclCopyArray(&handles);
    mxDestroyArray(handles);
    mxDestroyArray(eventdata);
    mxDestroyArray(hObject);
    mclSetCurrentLocalFunctionTable(save_local_function_table_);
    /*
     * % hObject    handle to Sd (see GCBO)
     * % eventdata  reserved - to be defined in a future version of MATLAB
     * % handles    structure with handles and user data (see GUIDATA)
     * 
     * % Hints: get(hObject,'String') returns contents of Sd as text
     * %        str2double(get(hObject,'String')) returns contents of Sd as a double
     * 
     * 
     * % --- Executes during object creation, after setting all properties.
     */
}

/*
 * The function "Mrecarga_2_3_Srz_CreateFcn" is the implementation version of
 * the "recarga_2_3/Srz_CreateFcn" M-function from file
 * "u:\final_recarga6\recarga\recarga_2_3.m" (lines 947-962). It contains the
 * actual compiled code for that M-function. It is a static function and must
 * only be called from one of the interface functions, appearing below.
 */
/*
 * function Srz_CreateFcn(hObject, eventdata, handles)
 */
static void Mrecarga_2_3_Srz_CreateFcn(mxArray * hObject,
                                       mxArray * eventdata,
                                       mxArray * handles) {
    mexLocalFunctionTable save_local_function_table_
      = mclSetCurrentLocalFunctionTable(&_local_function_table_recarga_2_3);
    mxArray * ans = NULL;
    mclCopyArray(&hObject);
    mclCopyArray(&eventdata);
    mclCopyArray(&handles);
    /*
     * % hObject    handle to Srz (see GCBO)
     * % eventdata  reserved - to be defined in a future version of MATLAB
     * % handles    empty - handles not created until after all CreateFcns called
     * 
     * % Hint: edit controls usually have a white background on Windows.
     * %       See ISPC and COMPUTER.
     * if ispc
     */
    if (mlfTobool(mlfIspc())) {
        /*
         * set(hObject,'BackgroundColor','white');
         */
        mclAssignAns(
          &ans,
          mlfNSet(
            0, mclVa(hObject, "hObject"), _mxarray28_, _mxarray30_, NULL));
    /*
     * else
     */
    } else {
        /*
         * set(hObject,'BackgroundColor',get(0,'defaultUicontrolBackgroundColor'));
         */
        mclAssignAns(
          &ans,
          mlfNSet(
            0,
            mclVa(hObject, "hObject"),
            _mxarray28_,
            mlfNGet(1, _mxarray32_, _mxarray33_, NULL),
            NULL));
    /*
     * end
     */
    }
    mxDestroyArray(ans);
    mxDestroyArray(handles);
    mxDestroyArray(eventdata);
    mxDestroyArray(hObject);
    mclSetCurrentLocalFunctionTable(save_local_function_table_);
    /*
     * 
     * 
     * 
     */
}

/*
 * The function "Mrecarga_2_3_Srz_Callback" is the implementation version of
 * the "recarga_2_3/Srz_Callback" M-function from file
 * "u:\final_recarga6\recarga\recarga_2_3.m" (lines 962-972). It contains the
 * actual compiled code for that M-function. It is a static function and must
 * only be called from one of the interface functions, appearing below.
 */
/*
 * function Srz_Callback(hObject, eventdata, handles)
 */
static void Mrecarga_2_3_Srz_Callback(mxArray * hObject,
                                      mxArray * eventdata,
                                      mxArray * handles) {
    mexLocalFunctionTable save_local_function_table_
      = mclSetCurrentLocalFunctionTable(&_local_function_table_recarga_2_3);
    mclCopyArray(&hObject);
    mclCopyArray(&eventdata);
    mclCopyArray(&handles);
    mxDestroyArray(handles);
    mxDestroyArray(eventdata);
    mxDestroyArray(hObject);
    mclSetCurrentLocalFunctionTable(save_local_function_table_);
    /*
     * % hObject    handle to Srz (see GCBO)
     * % eventdata  reserved - to be defined in a future version of MATLAB
     * % handles    structure with handles and user data (see GUIDATA)
     * 
     * % Hints: get(hObject,'String') returns contents of Srz as text
     * %        str2double(get(hObject,'String')) returns contents of Srz as a double
     * 
     * 
     * % --- Executes during object creation, after setting all properties.
     */
}

/*
 * The function "Mrecarga_2_3_St_CreateFcn" is the implementation version of
 * the "recarga_2_3/St_CreateFcn" M-function from file
 * "u:\final_recarga6\recarga\recarga_2_3.m" (lines 972-987). It contains the
 * actual compiled code for that M-function. It is a static function and must
 * only be called from one of the interface functions, appearing below.
 */
/*
 * function St_CreateFcn(hObject, eventdata, handles)
 */
static void Mrecarga_2_3_St_CreateFcn(mxArray * hObject,
                                      mxArray * eventdata,
                                      mxArray * handles) {
    mexLocalFunctionTable save_local_function_table_
      = mclSetCurrentLocalFunctionTable(&_local_function_table_recarga_2_3);
    mxArray * ans = NULL;
    mclCopyArray(&hObject);
    mclCopyArray(&eventdata);
    mclCopyArray(&handles);
    /*
     * % hObject    handle to St (see GCBO)
     * % eventdata  reserved - to be defined in a future version of MATLAB
     * % handles    empty - handles not created until after all CreateFcns called
     * 
     * % Hint: edit controls usually have a white background on Windows.
     * %       See ISPC and COMPUTER.
     * if ispc
     */
    if (mlfTobool(mlfIspc())) {
        /*
         * set(hObject,'BackgroundColor','white');
         */
        mclAssignAns(
          &ans,
          mlfNSet(
            0, mclVa(hObject, "hObject"), _mxarray28_, _mxarray30_, NULL));
    /*
     * else
     */
    } else {
        /*
         * set(hObject,'BackgroundColor',get(0,'defaultUicontrolBackgroundColor'));
         */
        mclAssignAns(
          &ans,
          mlfNSet(
            0,
            mclVa(hObject, "hObject"),
            _mxarray28_,
            mlfNGet(1, _mxarray32_, _mxarray33_, NULL),
            NULL));
    /*
     * end
     */
    }
    mxDestroyArray(ans);
    mxDestroyArray(handles);
    mxDestroyArray(eventdata);
    mxDestroyArray(hObject);
    mclSetCurrentLocalFunctionTable(save_local_function_table_);
    /*
     * 
     * 
     * 
     */
}

/*
 * The function "Mrecarga_2_3_St_Callback" is the implementation version of the
 * "recarga_2_3/St_Callback" M-function from file
 * "u:\final_recarga6\recarga\recarga_2_3.m" (lines 987-998). It contains the
 * actual compiled code for that M-function. It is a static function and must
 * only be called from one of the interface functions, appearing below.
 */
/*
 * function St_Callback(hObject, eventdata, handles)
 */
static void Mrecarga_2_3_St_Callback(mxArray * hObject,
                                     mxArray * eventdata,
                                     mxArray * handles) {
    mexLocalFunctionTable save_local_function_table_
      = mclSetCurrentLocalFunctionTable(&_local_function_table_recarga_2_3);
    mclCopyArray(&hObject);
    mclCopyArray(&eventdata);
    mclCopyArray(&handles);
    mxDestroyArray(handles);
    mxDestroyArray(eventdata);
    mxDestroyArray(hObject);
    mclSetCurrentLocalFunctionTable(save_local_function_table_);
    /*
     * % hObject    handle to St (see GCBO)
     * % eventdata  reserved - to be defined in a future version of MATLAB
     * % handles    structure with handles and user data (see GUIDATA)
     * 
     * % Hints: get(hObject,'String') returns contents of St as text
     * %        str2double(get(hObject,'String')) returns contents of St as a double
     * 
     * 
     * 
     * % --- Executes during object creation, after setting all properties.
     */
}

/*
 * The function "Mrecarga_2_3_Ksat_CreateFcn" is the implementation version of
 * the "recarga_2_3/Ksat_CreateFcn" M-function from file
 * "u:\final_recarga6\recarga\recarga_2_3.m" (lines 998-1013). It contains the
 * actual compiled code for that M-function. It is a static function and must
 * only be called from one of the interface functions, appearing below.
 */
/*
 * function Ksat_CreateFcn(hObject, eventdata, handles)
 */
static void Mrecarga_2_3_Ksat_CreateFcn(mxArray * hObject,
                                        mxArray * eventdata,
                                        mxArray * handles) {
    mexLocalFunctionTable save_local_function_table_
      = mclSetCurrentLocalFunctionTable(&_local_function_table_recarga_2_3);
    mxArray * ans = NULL;
    mclCopyArray(&hObject);
    mclCopyArray(&eventdata);
    mclCopyArray(&handles);
    /*
     * % hObject    handle to Ksat (see GCBO)
     * % eventdata  reserved - to be defined in a future version of MATLAB
     * % handles    empty - handles not created until after all CreateFcns called
     * 
     * % Hint: edit controls usually have a white background on Windows.
     * %       See ISPC and COMPUTER.
     * if ispc
     */
    if (mlfTobool(mlfIspc())) {
        /*
         * set(hObject,'BackgroundColor','white');
         */
        mclAssignAns(
          &ans,
          mlfNSet(
            0, mclVa(hObject, "hObject"), _mxarray28_, _mxarray30_, NULL));
    /*
     * else
     */
    } else {
        /*
         * set(hObject,'BackgroundColor',get(0,'defaultUicontrolBackgroundColor'));
         */
        mclAssignAns(
          &ans,
          mlfNSet(
            0,
            mclVa(hObject, "hObject"),
            _mxarray28_,
            mlfNGet(1, _mxarray32_, _mxarray33_, NULL),
            NULL));
    /*
     * end
     */
    }
    mxDestroyArray(ans);
    mxDestroyArray(handles);
    mxDestroyArray(eventdata);
    mxDestroyArray(hObject);
    mclSetCurrentLocalFunctionTable(save_local_function_table_);
    /*
     * 
     * 
     * 
     */
}

/*
 * The function "Mrecarga_2_3_Ksat_Callback" is the implementation version of
 * the "recarga_2_3/Ksat_Callback" M-function from file
 * "u:\final_recarga6\recarga\recarga_2_3.m" (lines 1013-1024). It contains the
 * actual compiled code for that M-function. It is a static function and must
 * only be called from one of the interface functions, appearing below.
 */
/*
 * function Ksat_Callback(hObject, eventdata, handles)
 */
static void Mrecarga_2_3_Ksat_Callback(mxArray * hObject,
                                       mxArray * eventdata,
                                       mxArray * handles) {
    mexLocalFunctionTable save_local_function_table_
      = mclSetCurrentLocalFunctionTable(&_local_function_table_recarga_2_3);
    mclCopyArray(&hObject);
    mclCopyArray(&eventdata);
    mclCopyArray(&handles);
    mxDestroyArray(handles);
    mxDestroyArray(eventdata);
    mxDestroyArray(hObject);
    mclSetCurrentLocalFunctionTable(save_local_function_table_);
    /*
     * % hObject    handle to Ksat (see GCBO)
     * % eventdata  reserved - to be defined in a future version of MATLAB
     * % handles    structure with handles and user data (see GUIDATA)
     * 
     * % Hints: get(hObject,'String') returns contents of Ksat as text
     * %        str2double(get(hObject,'String')) returns contents of Ksat as a double
     * 
     * 
     * 
     * % --- Executes during object creation, after setting all properties.
     */
}

/*
 * The function "Mrecarga_2_3_Input_CreateFcn" is the implementation version of
 * the "recarga_2_3/Input_CreateFcn" M-function from file
 * "u:\final_recarga6\recarga\recarga_2_3.m" (lines 1024-1039). It contains the
 * actual compiled code for that M-function. It is a static function and must
 * only be called from one of the interface functions, appearing below.
 */
/*
 * function Input_CreateFcn(hObject, eventdata, handles)
 */
static void Mrecarga_2_3_Input_CreateFcn(mxArray * hObject,
                                         mxArray * eventdata,
                                         mxArray * handles) {
    mexLocalFunctionTable save_local_function_table_
      = mclSetCurrentLocalFunctionTable(&_local_function_table_recarga_2_3);
    mxArray * ans = NULL;
    mclCopyArray(&hObject);
    mclCopyArray(&eventdata);
    mclCopyArray(&handles);
    /*
     * % hObject    handle to Input (see GCBO)
     * % eventdata  reserved - to be defined in a future version of MATLAB
     * % handles    empty - handles not created until after all CreateFcns called
     * 
     * % Hint: edit controls usually have a white background on Windows.
     * %       See ISPC and COMPUTER.
     * if ispc
     */
    if (mlfTobool(mlfIspc())) {
        /*
         * set(hObject,'BackgroundColor','white');
         */
        mclAssignAns(
          &ans,
          mlfNSet(
            0, mclVa(hObject, "hObject"), _mxarray28_, _mxarray30_, NULL));
    /*
     * else
     */
    } else {
        /*
         * set(hObject,'BackgroundColor',get(0,'defaultUicontrolBackgroundColor'));
         */
        mclAssignAns(
          &ans,
          mlfNSet(
            0,
            mclVa(hObject, "hObject"),
            _mxarray28_,
            mlfNGet(1, _mxarray32_, _mxarray33_, NULL),
            NULL));
    /*
     * end
     */
    }
    mxDestroyArray(ans);
    mxDestroyArray(handles);
    mxDestroyArray(eventdata);
    mxDestroyArray(hObject);
    mclSetCurrentLocalFunctionTable(save_local_function_table_);
    /*
     * 
     * 
     * 
     */
}

/*
 * The function "Mrecarga_2_3_Input_Callback" is the implementation version of
 * the "recarga_2_3/Input_Callback" M-function from file
 * "u:\final_recarga6\recarga\recarga_2_3.m" (lines 1039-1049). It contains the
 * actual compiled code for that M-function. It is a static function and must
 * only be called from one of the interface functions, appearing below.
 */
/*
 * function Input_Callback(hObject, eventdata, handles)
 */
static void Mrecarga_2_3_Input_Callback(mxArray * hObject,
                                        mxArray * eventdata,
                                        mxArray * handles) {
    mexLocalFunctionTable save_local_function_table_
      = mclSetCurrentLocalFunctionTable(&_local_function_table_recarga_2_3);
    mclCopyArray(&hObject);
    mclCopyArray(&eventdata);
    mclCopyArray(&handles);
    mxDestroyArray(handles);
    mxDestroyArray(eventdata);
    mxDestroyArray(hObject);
    mclSetCurrentLocalFunctionTable(save_local_function_table_);
    /*
     * % hObject    handle to Input (see GCBO)
     * % eventdata  reserved - to be defined in a future version of MATLAB
     * % handles    structure with handles and user data (see GUIDATA)
     * 
     * % Hints: get(hObject,'String') returns contents of Input as text
     * %        str2double(get(hObject,'String')) returns contents of Input as a double
     * 
     * 
     * % --- Executes during object creation, after setting all properties.
     */
}

/*
 * The function "Mrecarga_2_3_edit9_CreateFcn" is the implementation version of
 * the "recarga_2_3/edit9_CreateFcn" M-function from file
 * "u:\final_recarga6\recarga\recarga_2_3.m" (lines 1049-1064). It contains the
 * actual compiled code for that M-function. It is a static function and must
 * only be called from one of the interface functions, appearing below.
 */
/*
 * function edit9_CreateFcn(hObject, eventdata, handles)
 */
static void Mrecarga_2_3_edit9_CreateFcn(mxArray * hObject,
                                         mxArray * eventdata,
                                         mxArray * handles) {
    mexLocalFunctionTable save_local_function_table_
      = mclSetCurrentLocalFunctionTable(&_local_function_table_recarga_2_3);
    mxArray * ans = NULL;
    mclCopyArray(&hObject);
    mclCopyArray(&eventdata);
    mclCopyArray(&handles);
    /*
     * % hObject    handle to edit9 (see GCBO)
     * % eventdata  reserved - to be defined in a future version of MATLAB
     * % handles    empty - handles not created until after all CreateFcns called
     * 
     * % Hint: edit controls usually have a white background on Windows.
     * %       See ISPC and COMPUTER.
     * if ispc
     */
    if (mlfTobool(mlfIspc())) {
        /*
         * set(hObject,'BackgroundColor','white');
         */
        mclAssignAns(
          &ans,
          mlfNSet(
            0, mclVa(hObject, "hObject"), _mxarray28_, _mxarray30_, NULL));
    /*
     * else
     */
    } else {
        /*
         * set(hObject,'BackgroundColor',get(0,'defaultUicontrolBackgroundColor'));
         */
        mclAssignAns(
          &ans,
          mlfNSet(
            0,
            mclVa(hObject, "hObject"),
            _mxarray28_,
            mlfNGet(1, _mxarray32_, _mxarray33_, NULL),
            NULL));
    /*
     * end
     */
    }
    mxDestroyArray(ans);
    mxDestroyArray(handles);
    mxDestroyArray(eventdata);
    mxDestroyArray(hObject);
    mclSetCurrentLocalFunctionTable(save_local_function_table_);
    /*
     * 
     * 
     * 
     */
}

/*
 * The function "Mrecarga_2_3_edit9_Callback" is the implementation version of
 * the "recarga_2_3/edit9_Callback" M-function from file
 * "u:\final_recarga6\recarga\recarga_2_3.m" (lines 1064-1074). It contains the
 * actual compiled code for that M-function. It is a static function and must
 * only be called from one of the interface functions, appearing below.
 */
/*
 * function edit9_Callback(hObject, eventdata, handles)
 */
static void Mrecarga_2_3_edit9_Callback(mxArray * hObject,
                                        mxArray * eventdata,
                                        mxArray * handles) {
    mexLocalFunctionTable save_local_function_table_
      = mclSetCurrentLocalFunctionTable(&_local_function_table_recarga_2_3);
    mclCopyArray(&hObject);
    mclCopyArray(&eventdata);
    mclCopyArray(&handles);
    mxDestroyArray(handles);
    mxDestroyArray(eventdata);
    mxDestroyArray(hObject);
    mclSetCurrentLocalFunctionTable(save_local_function_table_);
    /*
     * % hObject    handle to edit9 (see GCBO)
     * % eventdata  reserved - to be defined in a future version of MATLAB
     * % handles    structure with handles and user data (see GUIDATA)
     * 
     * % Hints: get(hObject,'String') returns contents of edit9 as text
     * %        str2double(get(hObject,'String')) returns contents of edit9 as a double
     * 
     * 
     * % --- Executes during object creation, after setting all properties.
     */
}

/*
 * The function "Mrecarga_2_3_popupmenu1_CreateFcn" is the implementation
 * version of the "recarga_2_3/popupmenu1_CreateFcn" M-function from file
 * "u:\final_recarga6\recarga\recarga_2_3.m" (lines 1074-1089). It contains the
 * actual compiled code for that M-function. It is a static function and must
 * only be called from one of the interface functions, appearing below.
 */
/*
 * function popupmenu1_CreateFcn(hObject, eventdata, handles)
 */
static void Mrecarga_2_3_popupmenu1_CreateFcn(mxArray * hObject,
                                              mxArray * eventdata,
                                              mxArray * handles) {
    mexLocalFunctionTable save_local_function_table_
      = mclSetCurrentLocalFunctionTable(&_local_function_table_recarga_2_3);
    mxArray * ans = NULL;
    mclCopyArray(&hObject);
    mclCopyArray(&eventdata);
    mclCopyArray(&handles);
    /*
     * % hObject    handle to popupmenu1 (see GCBO)
     * % eventdata  reserved - to be defined in a future version of MATLAB
     * % handles    empty - handles not created until after all CreateFcns called
     * 
     * % Hint: popupmenu controls usually have a white background on Windows.
     * %       See ISPC and COMPUTER.
     * if ispc
     */
    if (mlfTobool(mlfIspc())) {
        /*
         * set(hObject,'BackgroundColor','white');
         */
        mclAssignAns(
          &ans,
          mlfNSet(
            0, mclVa(hObject, "hObject"), _mxarray28_, _mxarray30_, NULL));
    /*
     * else
     */
    } else {
        /*
         * set(hObject,'BackgroundColor',get(0,'defaultUicontrolBackgroundColor'));
         */
        mclAssignAns(
          &ans,
          mlfNSet(
            0,
            mclVa(hObject, "hObject"),
            _mxarray28_,
            mlfNGet(1, _mxarray32_, _mxarray33_, NULL),
            NULL));
    /*
     * end
     */
    }
    mxDestroyArray(ans);
    mxDestroyArray(handles);
    mxDestroyArray(eventdata);
    mxDestroyArray(hObject);
    mclSetCurrentLocalFunctionTable(save_local_function_table_);
    /*
     * 
     * 
     * % --- Executes on selection change in popupmenu1.
     */
}

/*
 * The function "Mrecarga_2_3_popupmenu1_Callback" is the implementation
 * version of the "recarga_2_3/popupmenu1_Callback" M-function from file
 * "u:\final_recarga6\recarga\recarga_2_3.m" (lines 1089-1099). It contains the
 * actual compiled code for that M-function. It is a static function and must
 * only be called from one of the interface functions, appearing below.
 */
/*
 * function popupmenu1_Callback(hObject, eventdata, handles)
 */
static void Mrecarga_2_3_popupmenu1_Callback(mxArray * hObject,
                                             mxArray * eventdata,
                                             mxArray * handles) {
    mexLocalFunctionTable save_local_function_table_
      = mclSetCurrentLocalFunctionTable(&_local_function_table_recarga_2_3);
    mclCopyArray(&hObject);
    mclCopyArray(&eventdata);
    mclCopyArray(&handles);
    mxDestroyArray(handles);
    mxDestroyArray(eventdata);
    mxDestroyArray(hObject);
    mclSetCurrentLocalFunctionTable(save_local_function_table_);
    /*
     * % hObject    handle to popupmenu1 (see GCBO)
     * % eventdata  reserved - to be defined in a future version of MATLAB
     * % handles    structure with handles and user data (see GUIDATA)
     * 
     * % Hints: contents = get(hObject,'String') returns popupmenu1 contents as cell array
     * %        contents{get(hObject,'Value')} returns selected item from popupmenu1
     * 
     * 
     * % --- Executes during object creation, after setting all properties.
     */
}

/*
 * The function "Mrecarga_2_3_Length_CreateFcn" is the implementation version
 * of the "recarga_2_3/Length_CreateFcn" M-function from file
 * "u:\final_recarga6\recarga\recarga_2_3.m" (lines 1099-1114). It contains the
 * actual compiled code for that M-function. It is a static function and must
 * only be called from one of the interface functions, appearing below.
 */
/*
 * function Length_CreateFcn(hObject, eventdata, handles)
 */
static void Mrecarga_2_3_Length_CreateFcn(mxArray * hObject,
                                          mxArray * eventdata,
                                          mxArray * handles) {
    mexLocalFunctionTable save_local_function_table_
      = mclSetCurrentLocalFunctionTable(&_local_function_table_recarga_2_3);
    mxArray * ans = NULL;
    mclCopyArray(&hObject);
    mclCopyArray(&eventdata);
    mclCopyArray(&handles);
    /*
     * % hObject    handle to Length (see GCBO)
     * % eventdata  reserved - to be defined in a future version of MATLAB
     * % handles    empty - handles not created until after all CreateFcns called
     * 
     * % Hint: edit controls usually have a white background on Windows.
     * %       See ISPC and COMPUTER.
     * if ispc
     */
    if (mlfTobool(mlfIspc())) {
        /*
         * set(hObject,'BackgroundColor','white');
         */
        mclAssignAns(
          &ans,
          mlfNSet(
            0, mclVa(hObject, "hObject"), _mxarray28_, _mxarray30_, NULL));
    /*
     * else
     */
    } else {
        /*
         * set(hObject,'BackgroundColor',get(0,'defaultUicontrolBackgroundColor'));
         */
        mclAssignAns(
          &ans,
          mlfNSet(
            0,
            mclVa(hObject, "hObject"),
            _mxarray28_,
            mlfNGet(1, _mxarray32_, _mxarray33_, NULL),
            NULL));
    /*
     * end
     */
    }
    mxDestroyArray(ans);
    mxDestroyArray(handles);
    mxDestroyArray(eventdata);
    mxDestroyArray(hObject);
    mclSetCurrentLocalFunctionTable(save_local_function_table_);
    /*
     * 
     * 
     * 
     */
}

/*
 * The function "Mrecarga_2_3_Length_Callback" is the implementation version of
 * the "recarga_2_3/Length_Callback" M-function from file
 * "u:\final_recarga6\recarga\recarga_2_3.m" (lines 1114-1124). It contains the
 * actual compiled code for that M-function. It is a static function and must
 * only be called from one of the interface functions, appearing below.
 */
/*
 * function Length_Callback(hObject, eventdata, handles)
 */
static void Mrecarga_2_3_Length_Callback(mxArray * hObject,
                                         mxArray * eventdata,
                                         mxArray * handles) {
    mexLocalFunctionTable save_local_function_table_
      = mclSetCurrentLocalFunctionTable(&_local_function_table_recarga_2_3);
    mclCopyArray(&hObject);
    mclCopyArray(&eventdata);
    mclCopyArray(&handles);
    mxDestroyArray(handles);
    mxDestroyArray(eventdata);
    mxDestroyArray(hObject);
    mclSetCurrentLocalFunctionTable(save_local_function_table_);
    /*
     * % hObject    handle to Length (see GCBO)
     * % eventdata  reserved - to be defined in a future version of MATLAB
     * % handles    structure with handles and user data (see GUIDATA)
     * 
     * % Hints: get(hObject,'String') returns contents of Length as text
     * %        str2double(get(hObject,'String')) returns contents of Length as a double
     * 
     * 
     * % --- Executes during object creation, after setting all properties.
     */
}

/*
 * The function "Mrecarga_2_3_Output_CreateFcn" is the implementation version
 * of the "recarga_2_3/Output_CreateFcn" M-function from file
 * "u:\final_recarga6\recarga\recarga_2_3.m" (lines 1124-1139). It contains the
 * actual compiled code for that M-function. It is a static function and must
 * only be called from one of the interface functions, appearing below.
 */
/*
 * function Output_CreateFcn(hObject, eventdata, handles)
 */
static void Mrecarga_2_3_Output_CreateFcn(mxArray * hObject,
                                          mxArray * eventdata,
                                          mxArray * handles) {
    mexLocalFunctionTable save_local_function_table_
      = mclSetCurrentLocalFunctionTable(&_local_function_table_recarga_2_3);
    mxArray * ans = NULL;
    mclCopyArray(&hObject);
    mclCopyArray(&eventdata);
    mclCopyArray(&handles);
    /*
     * % hObject    handle to Output (see GCBO)
     * % eventdata  reserved - to be defined in a future version of MATLAB
     * % handles    empty - handles not created until after all CreateFcns called
     * 
     * % Hint: edit controls usually have a white background on Windows.
     * %       See ISPC and COMPUTER.
     * if ispc
     */
    if (mlfTobool(mlfIspc())) {
        /*
         * set(hObject,'BackgroundColor','white');
         */
        mclAssignAns(
          &ans,
          mlfNSet(
            0, mclVa(hObject, "hObject"), _mxarray28_, _mxarray30_, NULL));
    /*
     * else
     */
    } else {
        /*
         * set(hObject,'BackgroundColor',get(0,'defaultUicontrolBackgroundColor'));
         */
        mclAssignAns(
          &ans,
          mlfNSet(
            0,
            mclVa(hObject, "hObject"),
            _mxarray28_,
            mlfNGet(1, _mxarray32_, _mxarray33_, NULL),
            NULL));
    /*
     * end
     */
    }
    mxDestroyArray(ans);
    mxDestroyArray(handles);
    mxDestroyArray(eventdata);
    mxDestroyArray(hObject);
    mclSetCurrentLocalFunctionTable(save_local_function_table_);
    /*
     * 
     * 
     * 
     */
}

/*
 * The function "Mrecarga_2_3_Output_Callback" is the implementation version of
 * the "recarga_2_3/Output_Callback" M-function from file
 * "u:\final_recarga6\recarga\recarga_2_3.m" (lines 1139-1149). It contains the
 * actual compiled code for that M-function. It is a static function and must
 * only be called from one of the interface functions, appearing below.
 */
/*
 * function Output_Callback(hObject, eventdata, handles)
 */
static void Mrecarga_2_3_Output_Callback(mxArray * hObject,
                                         mxArray * eventdata,
                                         mxArray * handles) {
    mexLocalFunctionTable save_local_function_table_
      = mclSetCurrentLocalFunctionTable(&_local_function_table_recarga_2_3);
    mclCopyArray(&hObject);
    mclCopyArray(&eventdata);
    mclCopyArray(&handles);
    mxDestroyArray(handles);
    mxDestroyArray(eventdata);
    mxDestroyArray(hObject);
    mclSetCurrentLocalFunctionTable(save_local_function_table_);
    /*
     * % hObject    handle to Output (see GCBO)
     * % eventdata  reserved - to be defined in a future version of MATLAB
     * % handles    structure with handles and user data (see GUIDATA)
     * 
     * % Hints: get(hObject,'String') returns contents of Output as text
     * %        str2double(get(hObject,'String')) returns contents of Output as a double
     * 
     * 
     * % --- Executes during object creation, after setting all properties.
     */
}

/*
 * The function "Mrecarga_2_3_Name_CreateFcn" is the implementation version of
 * the "recarga_2_3/Name_CreateFcn" M-function from file
 * "u:\final_recarga6\recarga\recarga_2_3.m" (lines 1149-1164). It contains the
 * actual compiled code for that M-function. It is a static function and must
 * only be called from one of the interface functions, appearing below.
 */
/*
 * function Name_CreateFcn(hObject, eventdata, handles)
 */
static void Mrecarga_2_3_Name_CreateFcn(mxArray * hObject,
                                        mxArray * eventdata,
                                        mxArray * handles) {
    mexLocalFunctionTable save_local_function_table_
      = mclSetCurrentLocalFunctionTable(&_local_function_table_recarga_2_3);
    mxArray * ans = NULL;
    mclCopyArray(&hObject);
    mclCopyArray(&eventdata);
    mclCopyArray(&handles);
    /*
     * % hObject    handle to Input (see GCBO)
     * % eventdata  reserved - to be defined in a future version of MATLAB
     * % handles    empty - handles not created until after all CreateFcns called
     * 
     * % Hint: popupmenu controls usually have a white background on Windows.
     * %       See ISPC and COMPUTER.
     * if ispc
     */
    if (mlfTobool(mlfIspc())) {
        /*
         * set(hObject,'BackgroundColor','white');
         */
        mclAssignAns(
          &ans,
          mlfNSet(
            0, mclVa(hObject, "hObject"), _mxarray28_, _mxarray30_, NULL));
    /*
     * else
     */
    } else {
        /*
         * set(hObject,'BackgroundColor',get(0,'defaultUicontrolBackgroundColor'));
         */
        mclAssignAns(
          &ans,
          mlfNSet(
            0,
            mclVa(hObject, "hObject"),
            _mxarray28_,
            mlfNGet(1, _mxarray32_, _mxarray33_, NULL),
            NULL));
    /*
     * end
     */
    }
    mxDestroyArray(ans);
    mxDestroyArray(handles);
    mxDestroyArray(eventdata);
    mxDestroyArray(hObject);
    mclSetCurrentLocalFunctionTable(save_local_function_table_);
    /*
     * 
     * 
     * % --- Executes on selection change in Input.
     */
}

/*
 * The function "Mrecarga_2_3_Name_Callback" is the implementation version of
 * the "recarga_2_3/Name_Callback" M-function from file
 * "u:\final_recarga6\recarga\recarga_2_3.m" (lines 1164-1176). It contains the
 * actual compiled code for that M-function. It is a static function and must
 * only be called from one of the interface functions, appearing below.
 */
/*
 * function Name_Callback(hObject, eventdata, handles)
 */
static void Mrecarga_2_3_Name_Callback(mxArray * hObject,
                                       mxArray * eventdata,
                                       mxArray * handles) {
    mexLocalFunctionTable save_local_function_table_
      = mclSetCurrentLocalFunctionTable(&_local_function_table_recarga_2_3);
    mclCopyArray(&hObject);
    mclCopyArray(&eventdata);
    mclCopyArray(&handles);
    mxDestroyArray(handles);
    mxDestroyArray(eventdata);
    mxDestroyArray(hObject);
    mclSetCurrentLocalFunctionTable(save_local_function_table_);
    /*
     * % hObject    handle to Input (see GCBO)
     * % eventdata  reserved - to be defined in a future version of MATLAB
     * % handles    structure with handles and user data (see GUIDATA)
     * 
     * 
     * % Hints: contents = get(hObject,'String') returns Input contents as cell array
     * %        contents{get(hObject,'Value')} returns selected item from Input
     * 
     * 
     * 
     * % --- Executes during object creation, after setting all properties.
     */
}

/*
 * The function "Mrecarga_2_3_RGArea_CreateFcn" is the implementation version
 * of the "recarga_2_3/RGArea_CreateFcn" M-function from file
 * "u:\final_recarga6\recarga\recarga_2_3.m" (lines 1176-1192). It contains the
 * actual compiled code for that M-function. It is a static function and must
 * only be called from one of the interface functions, appearing below.
 */
/*
 * function RGArea_CreateFcn(hObject, eventdata, handles)
 */
static void Mrecarga_2_3_RGArea_CreateFcn(mxArray * hObject,
                                          mxArray * eventdata,
                                          mxArray * handles) {
    mexLocalFunctionTable save_local_function_table_
      = mclSetCurrentLocalFunctionTable(&_local_function_table_recarga_2_3);
    mxArray * ans = NULL;
    mclCopyArray(&hObject);
    mclCopyArray(&eventdata);
    mclCopyArray(&handles);
    /*
     * % hObject    handle to RGArea (see GCBO)
     * % eventdata  reserved - to be defined in a future version of MATLAB
     * % handles    empty - handles not created until after all CreateFcns called
     * 
     * % Hint: edit controls usually have a white background on Windows.
     * %       See ISPC and COMPUTER.
     * 
     * if ispc
     */
    if (mlfTobool(mlfIspc())) {
        /*
         * set(hObject,'BackgroundColor','white');
         */
        mclAssignAns(
          &ans,
          mlfNSet(
            0, mclVa(hObject, "hObject"), _mxarray28_, _mxarray30_, NULL));
    /*
     * else
     */
    } else {
        /*
         * set(hObject,'BackgroundColor',get(0,'defaultUicontrolBackgroundColor'));
         */
        mclAssignAns(
          &ans,
          mlfNSet(
            0,
            mclVa(hObject, "hObject"),
            _mxarray28_,
            mlfNGet(1, _mxarray32_, _mxarray33_, NULL),
            NULL));
    /*
     * end
     */
    }
    mxDestroyArray(ans);
    mxDestroyArray(handles);
    mxDestroyArray(eventdata);
    mxDestroyArray(hObject);
    mclSetCurrentLocalFunctionTable(save_local_function_table_);
    /*
     * 
     * 
     * 
     */
}

/*
 * The function "Mrecarga_2_3_RGArea_Callback" is the implementation version of
 * the "recarga_2_3/RGArea_Callback" M-function from file
 * "u:\final_recarga6\recarga\recarga_2_3.m" (lines 1192-1220). It contains the
 * actual compiled code for that M-function. It is a static function and must
 * only be called from one of the interface functions, appearing below.
 */
/*
 * function RGArea_Callback(hObject, eventdata, handles)
 */
static void Mrecarga_2_3_RGArea_Callback(mxArray * hObject,
                                         mxArray * eventdata,
                                         mxArray * handles) {
    mexLocalFunctionTable save_local_function_table_
      = mclSetCurrentLocalFunctionTable(&_local_function_table_recarga_2_3);
    mxArray * ans = NULL;
    mxArray * unit = NULL;
    mxArray * udiam = NULL;
    mxArray * pi = NULL;
    mxArray * g = NULL;
    mxArray * Co = NULL;
    mxArray * hmax = NULL;
    mxArray * Umax = NULL;
    mxArray * UD_Flow = NULL;
    mxArray * Srz = NULL;
    mxArray * dmin = NULL;
    mxArray * Arg = NULL;
    mclCopyArray(&hObject);
    mclCopyArray(&eventdata);
    mclCopyArray(&handles);
    /*
     * % hObject    handle to RGArea (see GCBO)
     * % eventdata  reserved - to be defined in a future version of MATLAB
     * % handles    structure with handles and user data (see GUIDATA)
     * 
     * % Hints: get(hObject,'String') returns contents of RGArea as text
     * %        str2double(get(hObject,'String')) returns contents of RGArea as a double
     * % --- Executes on button press in RGCalc.
     * %%GOHERE
     * Arg = str2num(get(hObject,'String'));  %Bioretention Cell Size 
     */
    mlfAssign(
      &Arg,
      mlfStr2num(
        NULL, mlfNGet(1, mclVa(hObject, "hObject"), _mxarray35_, NULL)));
    /*
     * dmin = str2num(get(handles.Sd,'String'));
     */
    mlfAssign(
      &dmin,
      mlfStr2num(
        NULL,
        mlfNGet(
          1,
          mlfIndexRef(mclVa(handles, "handles"), ".Sd"), _mxarray35_, NULL)));
    /*
     * Srz = str2num(get(handles.Srz,'String'));
     */
    mlfAssign(
      &Srz,
      mlfStr2num(
        NULL,
        mlfNGet(
          1,
          mlfIndexRef(mclVa(handles, "handles"), ".Srz"), _mxarray35_, NULL)));
    /*
     * UD_Flow = str2double(get(handles.UFlow,'String'));
     */
    mlfAssign(
      &UD_Flow,
      mlfStr2double(
        mlfNGet(
          1,
          mlfIndexRef(mclVa(handles, "handles"), ".UFlow"),
          _mxarray35_,
          NULL)));
    /*
     * Umax = (UD_Flow/100)*(Arg/3600); %Max. Underdrain flow [m3/sec]
     */
    mlfAssign(
      &Umax,
      mclMtimes(
        mclMrdivide(mclVv(UD_Flow, "UD_Flow"), _mxarray37_),
        mclMrdivide(mclVv(Arg, "Arg"), _mxarray38_)));
    /*
     * hmax = (dmin + Srz)/100;  %Max. Head on underdrain [m]
     */
    mlfAssign(
      &hmax,
      mclMrdivide(
        mclPlus(mclVv(dmin, "dmin"), mclVv(Srz, "Srz")), _mxarray37_));
    /*
     * Co = 0.62; g=9.81; pi=3.1457; %constants
     */
    mlfAssign(&Co, _mxarray39_);
    mlfAssign(&g, _mxarray40_);
    mlfAssign(&pi, _mxarray41_);
    /*
     * udiam = 2*sqrt((Umax/(Co*pi*sqrt(2*g*hmax))))*1000;  %underdrain diameter [m]
     */
    mlfAssign(
      &udiam,
      mclMtimes(
        mclMtimes(
          _mxarray42_,
          mlfSqrt(
            mclMrdivide(
              mclVv(Umax, "Umax"),
              mclMtimes(
                mclMtimes(mclVv(Co, "Co"), mclVv(pi, "pi")),
                mlfSqrt(
                  mclMtimes(
                    mclMtimes(_mxarray42_, mclVv(g, "g")),
                    mclVv(hmax, "hmax"))))))),
        _mxarray43_));
    /*
     * unit = get(handles.Units,'Value');
     */
    mlfAssign(
      &unit,
      mlfNGet(
        1,
        mlfIndexRef(mclVa(handles, "handles"), ".Units"), _mxarray44_, NULL));
    /*
     * if unit == 2
     */
    if (mclEqBool(mclVv(unit, "unit"), _mxarray42_)) {
        /*
         * g = 32.18503937007874015748031496063;
         */
        mlfAssign(&g, _mxarray46_);
        /*
         * hmax = (dmin + Srz)/12; %Max. Head on underdrain [ft]
         */
        mlfAssign(
          &hmax,
          mclMrdivide(
            mclPlus(mclVv(dmin, "dmin"), mclVv(Srz, "Srz")), _mxarray47_));
        /*
         * Umax = (UD_Flow/12)*(Arg/3600); %Max. Underdrain flow [ft3/sec]
         */
        mlfAssign(
          &Umax,
          mclMtimes(
            mclMrdivide(mclVv(UD_Flow, "UD_Flow"), _mxarray47_),
            mclMrdivide(mclVv(Arg, "Arg"), _mxarray38_)));
        /*
         * udiam = 2*sqrt((Umax/(Co*pi*sqrt(2*g*hmax))))*12;  %underdrain diameter [ft]
         */
        mlfAssign(
          &udiam,
          mclMtimes(
            mclMtimes(
              _mxarray42_,
              mlfSqrt(
                mclMrdivide(
                  mclVv(Umax, "Umax"),
                  mclMtimes(
                    mclMtimes(mclVv(Co, "Co"), mclVv(pi, "pi")),
                    mlfSqrt(
                      mclMtimes(
                        mclMtimes(_mxarray42_, mclVv(g, "g")),
                        mclVv(hmax, "hmax"))))))),
            _mxarray47_));
    /*
     * end
     */
    }
    /*
     * 
     * set(handles.Udiam,'String',num2str(udiam));  %display resultant underdrain diam in figure
     */
    mclAssignAns(
      &ans,
      mlfNSet(
        0,
        mlfIndexRef(mclVa(handles, "handles"), ".Udiam"),
        _mxarray35_,
        mlfNum2str(mclVv(udiam, "udiam"), NULL),
        NULL));
    mxDestroyArray(Arg);
    mxDestroyArray(dmin);
    mxDestroyArray(Srz);
    mxDestroyArray(UD_Flow);
    mxDestroyArray(Umax);
    mxDestroyArray(hmax);
    mxDestroyArray(Co);
    mxDestroyArray(g);
    mxDestroyArray(pi);
    mxDestroyArray(udiam);
    mxDestroyArray(unit);
    mxDestroyArray(ans);
    mxDestroyArray(handles);
    mxDestroyArray(eventdata);
    mxDestroyArray(hObject);
    mclSetCurrentLocalFunctionTable(save_local_function_table_);
    /*
     * 
     * 
     */
}

/*
 * The function "Mrecarga_2_3_RGCalc_Callback" is the implementation version of
 * the "recarga_2_3/RGCalc_Callback" M-function from file
 * "u:\final_recarga6\recarga\recarga_2_3.m" (lines 1220-1370). It contains the
 * actual compiled code for that M-function. It is a static function and must
 * only be called from one of the interface functions, appearing below.
 */
/*
 * function RGCalc_Callback(hObject, eventdata, handles)
 */
static void Mrecarga_2_3_RGCalc_Callback(mxArray * hObject,
                                         mxArray * eventdata,
                                         mxArray * handles) {
    mexLocalFunctionTable save_local_function_table_
      = mclSetCurrentLocalFunctionTable(&_local_function_table_recarga_2_3);
    mxArray * ans = NULL;
    mxArray * Dstay = NULL;
    mxArray * inot = NULL;
    mxArray * tstponded = NULL;
    mxArray * maxpond = NULL;
    mxArray * Dstore = NULL;
    mxArray * Dudrain = NULL;
    mxArray * Drecharge = NULL;
    mxArray * Devap = NULL;
    mxArray * Drunoff = NULL;
    mxArray * Drunon = NULL;
    mxArray * Dperv = NULL;
    mxArray * Dimp = NULL;
    mxArray * Dprecip = NULL;
    mxArray * PptFile = NULL;
    mxArray * PptDepth = NULL;
    mxArray * PptName = NULL;
    mxArray * PptType = NULL;
    mxArray * nprecip = NULL;
    mxArray * infile = NULL;
    mxArray * filename = NULL;
    mxArray * fileext = NULL;
    mxArray * Record = NULL;
    mxArray * Summary = NULL;
    mxArray * outname = NULL;
    mxArray * stime = NULL;
    mxArray * dt = NULL;
    mxArray * time = NULL;
    mxArray * rundays = NULL;
    mxArray * HydroCalc = NULL;
    mxArray * Umax = NULL;
    mxArray * Urate = NULL;
    mxArray * Kst = NULL;
    mxArray * Krz = NULL;
    mxArray * Kcz = NULL;
    mxArray * Scz = NULL;
    mxArray * Srz = NULL;
    mxArray * St = NULL;
    mxArray * dmin = NULL;
    mxArray * RTexture = NULL;
    mxArray * STexture = NULL;
    mxArray * NTexture = NULL;
    mxArray * Ssoilnumber = NULL;
    mxArray * Rsoilnumber = NULL;
    mxArray * Nsoilnumber = NULL;
    mxArray * soilnames = NULL;
    mxArray * soilsdata = NULL;
    mxArray * avet = NULL;
    mxArray * Sd = NULL;
    mxArray * CN = NULL;
    mxArray * TribA = NULL;
    mxArray * Arg = NULL;
    mxArray * EIA = NULL;
    mxArray * unit = NULL;
    mclCopyArray(&hObject);
    mclCopyArray(&eventdata);
    mclCopyArray(&handles);
    /*
     * % hObject    handle to RGCalc (see GCBO)
     * % eventdata  reserved - to be defined in a future version of MATLAB
     * % handles    structure with handles and user data (see GUIDATA)
     * 
     * %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
     * % UNITS
     * %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
     * unit = get(handles.Units,'Value');
     */
    mlfAssign(
      &unit,
      mlfNGet(
        1,
        mlfIndexRef(mclVa(handles, "handles"), ".Units"), _mxarray44_, NULL));
    /*
     * 
     * %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
     * % TRIBUTARY BASIN PARAMETERS
     * %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
     * EIA = str2num(get(handles.ImpA,'String'));  %Percent impervious area
     */
    mlfAssign(
      &EIA,
      mlfStr2num(
        NULL,
        mlfNGet(
          1,
          mlfIndexRef(mclVa(handles, "handles"), ".ImpA"), _mxarray35_, NULL)));
    /*
     * Arg = str2num(get(handles.RGArea,'String'));  %Bioretention Cell Size 
     */
    mlfAssign(
      &Arg,
      mlfStr2num(
        NULL,
        mlfNGet(
          1,
          mlfIndexRef(mclVa(handles, "handles"), ".RGArea"),
          _mxarray35_,
          NULL)));
    /*
     * TribA = str2num(get(handles.BasinArea,'String'));  %Total Tributary Area
     */
    mlfAssign(
      &TribA,
      mlfStr2num(
        NULL,
        mlfNGet(
          1,
          mlfIndexRef(mclVa(handles, "handles"), ".BasinArea"),
          _mxarray35_,
          NULL)));
    /*
     * CN = str2num(get(handles.CN,'String'));
     */
    mlfAssign(
      &CN,
      mlfStr2num(
        NULL,
        mlfNGet(
          1,
          mlfIndexRef(mclVa(handles, "handles"), ".CN"), _mxarray35_, NULL)));
    /*
     * %g=9.8;		% acceleration of gravity [m/s2]
     * Sd=.35;		% depression storage in pervious area [cm]
     */
    mlfAssign(&Sd, _mxarray50_);
    /*
     * %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
     * % EVAPORATION PARAMETERS
     * %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
     * avet= str2num(get(handles.AveET,'String'));
     */
    mlfAssign(
      &avet,
      mlfStr2num(
        NULL,
        mlfNGet(
          1,
          mlfIndexRef(mclVa(handles, "handles"), ".AveET"),
          _mxarray35_,
          NULL)));
    /*
     * %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
     * % SOIL SENSITIVITY PARAMETERS:
     * %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
     * if unit ==1
     */
    if (mclEqBool(mclVv(unit, "unit"), _mxarray0_)) {
        /*
         * soilsdata=dlmread('soilsDNR.txt','\t',[0 1 10 4]);
         */
        mlfAssign(
          &soilsdata,
          mlfDlmread(_mxarray51_, _mxarray53_, _mxarray55_, NULL, NULL));
    /*
     * else
     */
    } else {
        /*
         * soilsdata=dlmread('soilsUS.txt','\t',[0 1 10 4]);
         */
        mlfAssign(
          &soilsdata,
          mlfDlmread(_mxarray57_, _mxarray53_, _mxarray55_, NULL, NULL));
    /*
     * end
     */
    }
    /*
     * soilnames=textread('soilslist.txt','%s','delimiter','\n','whitespace','');
     */
    mlfAssign(
      &soilnames,
      mlfNTextread(
        0,
        mclValueVarargout(),
        _mxarray59_,
        _mxarray61_,
        _mxarray63_,
        _mxarray65_,
        _mxarray67_,
        _mxarray69_,
        NULL));
    /*
     * Nsoilnumber = get(handles.NativeTexture,'Value');
     */
    mlfAssign(
      &Nsoilnumber,
      mlfNGet(
        1,
        mlfIndexRef(mclVa(handles, "handles"), ".NativeTexture"),
        _mxarray44_,
        NULL));
    /*
     * Rsoilnumber = get(handles.RootTexture,'Value');
     */
    mlfAssign(
      &Rsoilnumber,
      mlfNGet(
        1,
        mlfIndexRef(mclVa(handles, "handles"), ".RootTexture"),
        _mxarray44_,
        NULL));
    /*
     * Ssoilnumber = get(handles.StorageTexture,'Value');
     */
    mlfAssign(
      &Ssoilnumber,
      mlfNGet(
        1,
        mlfIndexRef(mclVa(handles, "handles"), ".StorageTexture"),
        _mxarray44_,
        NULL));
    /*
     * NTexture = soilnames(Nsoilnumber,1);
     */
    mlfAssign(
      &NTexture,
      mclArrayRef2(
        mclVv(soilnames, "soilnames"),
        mclVv(Nsoilnumber, "Nsoilnumber"),
        _mxarray0_));
    /*
     * STexture = soilnames(Ssoilnumber,1);
     */
    mlfAssign(
      &STexture,
      mclArrayRef2(
        mclVv(soilnames, "soilnames"),
        mclVv(Ssoilnumber, "Ssoilnumber"),
        _mxarray0_));
    /*
     * RTexture = soilnames(Rsoilnumber,1);
     */
    mlfAssign(
      &RTexture,
      mclArrayRef2(
        mclVv(soilnames, "soilnames"),
        mclVv(Rsoilnumber, "Rsoilnumber"),
        _mxarray0_));
    /*
     * dmin = str2num(get(handles.Sd,'String'));
     */
    mlfAssign(
      &dmin,
      mlfStr2num(
        NULL,
        mlfNGet(
          1,
          mlfIndexRef(mclVa(handles, "handles"), ".Sd"), _mxarray35_, NULL)));
    /*
     * St = str2num(get(handles.St,'String'));  %Storage Zone thickness
     */
    mlfAssign(
      &St,
      mlfStr2num(
        NULL,
        mlfNGet(
          1,
          mlfIndexRef(mclVa(handles, "handles"), ".St"), _mxarray35_, NULL)));
    /*
     * Srz = str2num(get(handles.Srz,'String'));  %Root Zone thickness
     */
    mlfAssign(
      &Srz,
      mlfStr2num(
        NULL,
        mlfNGet(
          1,
          mlfIndexRef(mclVa(handles, "handles"), ".Srz"), _mxarray35_, NULL)));
    /*
     * Scz = 10;  %Default value for Control Zone thickness
     */
    mlfAssign(&Scz, _mxarray70_);
    /*
     * Kcz= str2num(get(handles.Ksat,'String'));  %Control Zone Sat. Hydraulic Conductivity
     */
    mlfAssign(
      &Kcz,
      mlfStr2num(
        NULL,
        mlfNGet(
          1,
          mlfIndexRef(mclVa(handles, "handles"), ".Ksat"), _mxarray35_, NULL)));
    /*
     * Krz = str2num(get(handles.Kroot,'String'));  %Root Zone Sat. Hydraulic Conductivity
     */
    mlfAssign(
      &Krz,
      mlfStr2num(
        NULL,
        mlfNGet(
          1,
          mlfIndexRef(mclVa(handles, "handles"), ".Kroot"),
          _mxarray35_,
          NULL)));
    /*
     * Kst = str2num(get(handles.Kstore,'String')); %Storage Zone Sat. Hydraulic Conductivity
     */
    mlfAssign(
      &Kst,
      mlfStr2num(
        NULL,
        mlfNGet(
          1,
          mlfIndexRef(mclVa(handles, "handles"), ".Kstore"),
          _mxarray35_,
          NULL)));
    /*
     * if St==0    %Allow for no storage by dividing control zone into two equal layers
     */
    if (mclEqBool(mclVv(St, "St"), _mxarray32_)) {
        /*
         * St=5;  
         */
        mlfAssign(&St, _mxarray71_);
        /*
         * Scz=5;
         */
        mlfAssign(&Scz, _mxarray71_);
        /*
         * Kst = Kcz;
         */
        mlfAssign(&Kst, mclVv(Kcz, "Kcz"));
        /*
         * STexture = NTexture;
         */
        mlfAssign(&STexture, mclVv(NTexture, "NTexture"));
    /*
     * end
     */
    }
    /*
     * %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
     * %  UNDERDRAIN SIZING
     * %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
     * Urate = str2num(get(handles.UFlow,'String'));
     */
    mlfAssign(
      &Urate,
      mlfStr2num(
        NULL,
        mlfNGet(
          1,
          mlfIndexRef(mclVa(handles, "handles"), ".UFlow"),
          _mxarray35_,
          NULL)));
    /*
     * Umax = (Urate/100)*(Arg/3600); %Max. Underdrain flow [m3/sec]
     */
    mlfAssign(
      &Umax,
      mclMtimes(
        mclMrdivide(mclVv(Urate, "Urate"), _mxarray37_),
        mclMrdivide(mclVv(Arg, "Arg"), _mxarray38_)));
    /*
     * %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
     * % MODELING PARAMETERS
     * %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
     * % TEMPORAL:
     * HydroCalc = get(handles.SimType,'Value');  %1: Continuous, 2: Single Event, 3: User Type
     */
    mlfAssign(
      &HydroCalc,
      mlfNGet(
        1,
        mlfIndexRef(mclVa(handles, "handles"), ".SimType"), _mxarray44_, NULL));
    /*
     * if HydroCalc == 2
     */
    if (mclEqBool(mclVv(HydroCalc, "HydroCalc"), _mxarray42_)) {
        /*
         * rundays = 3;
         */
        mlfAssign(&rundays, _mxarray72_);
    /*
     * else rundays = str2num(get(handles.Length,'String'));
     */
    } else {
        mlfAssign(
          &rundays,
          mlfStr2num(
            NULL,
            mlfNGet(
              1,
              mlfIndexRef(mclVa(handles, "handles"), ".Length"),
              _mxarray35_,
              NULL)));
    /*
     * end
     */
    }
    /*
     * time=rundays*24*60;			% min in data file
     */
    mlfAssign(
      &time,
      mclMtimes(
        mclMtimes(mclVv(rundays, "rundays"), _mxarray49_), _mxarray73_));
    /*
     * dt=15;						% TIME STEP [min]
     */
    mlfAssign(&dt, _mxarray74_);
    /*
     * stime=time/60;				% total time of simulation [h]
     */
    mlfAssign(&stime, mclMrdivide(mclVv(time, "time"), _mxarray73_));
    /*
     * dt=dt/60;					% TIME STEP [h]
     */
    mlfAssign(&dt, mclMrdivide(mclVv(dt, "dt"), _mxarray73_));
    /*
     * %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
     * %DATAFILE RETRIEVAL
     * %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
     * outname = get(handles.Output,'String');
     */
    mlfAssign(
      &outname,
      mlfNGet(
        1,
        mlfIndexRef(mclVa(handles, "handles"), ".Output"), _mxarray35_, NULL));
    /*
     * Summary = get(handles.Summary,'Value');
     */
    mlfAssign(
      &Summary,
      mlfNGet(
        1,
        mlfIndexRef(mclVa(handles, "handles"), ".Summary"), _mxarray44_, NULL));
    /*
     * Record = get(handles.Record,'Value');
     */
    mlfAssign(
      &Record,
      mlfNGet(
        1,
        mlfIndexRef(mclVa(handles, "handles"), ".Record"), _mxarray44_, NULL));
    /*
     * fileext = '.txt';
     */
    mlfAssign(&fileext, _mxarray75_);
    /*
     * if HydroCalc == 1
     */
    if (mclEqBool(mclVv(HydroCalc, "HydroCalc"), _mxarray0_)) {
        /*
         * filename = get(handles.Input,'String');
         */
        mlfAssign(
          &filename,
          mlfNGet(
            1,
            mlfIndexRef(mclVa(handles, "handles"), ".Input"),
            _mxarray35_,
            NULL));
        /*
         * infile = strcat(filename,fileext);
         */
        mlfAssign(
          &infile,
          mlfStrcat(
            mclVv(filename, "filename"), mclVv(fileext, "fileext"), NULL));
        /*
         * nprecip=dlmread(infile,'\t',[1 0 ceil(stime)+1 2]);
         */
        mlfAssign(
          &nprecip,
          mlfDlmread(
            mclVv(infile, "infile"),
            _mxarray53_,
            mlfHorzcat(
              _mxarray0_,
              _mxarray32_,
              mclPlus(mlfCeil(mclVv(stime, "stime")), _mxarray0_),
              _mxarray42_,
              NULL),
            NULL,
            NULL));
        /*
         * if unit ==1 
         */
        if (mclEqBool(mclVv(unit, "unit"), _mxarray0_)) {
            /*
             * nprecip(:,2)=nprecip(:,2)./10;      %convert Precip from [mm h-1] to [cm h-1]
             */
            mclArrayAssign2(
              &nprecip,
              mclRdivide(
                mclArrayRef2(
                  mclVv(nprecip, "nprecip"),
                  mlfCreateColonIndex(),
                  _mxarray42_),
                _mxarray70_),
              mlfCreateColonIndex(),
              _mxarray42_);
            /*
             * nprecip(:,3)=nprecip(:,3)./10;      %convert Evap from [mm h-1] to [cm h-1]
             */
            mclArrayAssign2(
              &nprecip,
              mclRdivide(
                mclArrayRef2(
                  mclVv(nprecip, "nprecip"),
                  mlfCreateColonIndex(),
                  _mxarray72_),
                _mxarray70_),
              mlfCreateColonIndex(),
              _mxarray72_);
        /*
         * else
         */
        } else {
        /*
         * end
         */
        }
    /*
     * elseif HydroCalc == 2
     */
    } else if (mclEqBool(mclVv(HydroCalc, "HydroCalc"), _mxarray42_)) {
        /*
         * PptType = get(handles.PptType,'Value'); %1: Type I, 2: Type IA, 3: Type II, 4: Type III
         */
        mlfAssign(
          &PptType,
          mlfNGet(
            1,
            mlfIndexRef(mclVa(handles, "handles"), ".PptType"),
            _mxarray44_,
            NULL));
        /*
         * if PptType == 1
         */
        if (mclEqBool(mclVv(PptType, "PptType"), _mxarray0_)) {
            /*
             * PptName = 'TypeI';
             */
            mlfAssign(&PptName, _mxarray77_);
        /*
         * elseif PptType ==2 
         */
        } else if (mclEqBool(mclVv(PptType, "PptType"), _mxarray42_)) {
            /*
             * PptName = 'TypeIA'; 
             */
            mlfAssign(&PptName, _mxarray79_);
        /*
         * elseif PptType == 3 
         */
        } else if (mclEqBool(mclVv(PptType, "PptType"), _mxarray72_)) {
            /*
             * PptName = 'TypeII';
             */
            mlfAssign(&PptName, _mxarray81_);
        /*
         * else 
         */
        } else {
            /*
             * PptName = 'TypeIII';
             */
            mlfAssign(&PptName, _mxarray83_);
        /*
         * end
         */
        }
        /*
         * PptDepth = str2num(get(handles.PptDepth,'String'));
         */
        mlfAssign(
          &PptDepth,
          mlfStr2num(
            NULL,
            mlfNGet(
              1,
              mlfIndexRef(mclVa(handles, "handles"), ".PptDepth"),
              _mxarray35_,
              NULL)));
        /*
         * PptFile = num2str(strcat(PptName,'.txt'));
         */
        mlfAssign(
          &PptFile,
          mlfNum2str(
            mlfStrcat(mclVv(PptName, "PptName"), _mxarray75_, NULL), NULL));
        /*
         * nprecip = dlmread(PptFile,'\t',[1 0 ceil(stime)+1 2]);
         */
        mlfAssign(
          &nprecip,
          mlfDlmread(
            mclVv(PptFile, "PptFile"),
            _mxarray53_,
            mlfHorzcat(
              _mxarray0_,
              _mxarray32_,
              mclPlus(mlfCeil(mclVv(stime, "stime")), _mxarray0_),
              _mxarray42_,
              NULL),
            NULL,
            NULL));
        /*
         * nprecip(:,2)=nprecip(:,2).*PptDepth;      %convert Precip from [mm h-1] to [cm h-1]
         */
        mclArrayAssign2(
          &nprecip,
          mclTimes(
            mclArrayRef2(
              mclVv(nprecip, "nprecip"), mlfCreateColonIndex(), _mxarray42_),
            mclVv(PptDepth, "PptDepth")),
          mlfCreateColonIndex(),
          _mxarray42_);
        /*
         * nprecip(:,3)=nprecip(:,3).*avet/24;      %convert Evap from [mm h-1] to [cm h-1]
         */
        mclArrayAssign2(
          &nprecip,
          mclMrdivide(
            mclTimes(
              mclArrayRef2(
                mclVv(nprecip, "nprecip"), mlfCreateColonIndex(), _mxarray72_),
              mclVv(avet, "avet")),
            _mxarray49_),
          mlfCreateColonIndex(),
          _mxarray72_);
    /*
     * else
     */
    } else {
        /*
         * Sd = 0;  
         */
        mlfAssign(&Sd, _mxarray32_);
        /*
         * EIA = 100;
         */
        mlfAssign(&EIA, _mxarray37_);
        /*
         * filename = get(handles.Input,'String');
         */
        mlfAssign(
          &filename,
          mlfNGet(
            1,
            mlfIndexRef(mclVa(handles, "handles"), ".Input"),
            _mxarray35_,
            NULL));
        /*
         * infile = strcat(filename,fileext);
         */
        mlfAssign(
          &infile,
          mlfStrcat(
            mclVv(filename, "filename"), mclVv(fileext, "fileext"), NULL));
        /*
         * nprecip=dlmread(infile,'\t',[1 0 ceil(stime)+1 2]);
         */
        mlfAssign(
          &nprecip,
          mlfDlmread(
            mclVv(infile, "infile"),
            _mxarray53_,
            mlfHorzcat(
              _mxarray0_,
              _mxarray32_,
              mclPlus(mlfCeil(mclVv(stime, "stime")), _mxarray0_),
              _mxarray42_,
              NULL),
            NULL,
            NULL));
        /*
         * 
         * if unit == 1
         */
        if (mclEqBool(mclVv(unit, "unit"), _mxarray0_)) {
            /*
             * nprecip(:,2)=nprecip(:,2)./10;      %convert Precip from [mm h-1] to [cm h-1]
             */
            mclArrayAssign2(
              &nprecip,
              mclRdivide(
                mclArrayRef2(
                  mclVv(nprecip, "nprecip"),
                  mlfCreateColonIndex(),
                  _mxarray42_),
                _mxarray70_),
              mlfCreateColonIndex(),
              _mxarray42_);
            /*
             * nprecip(:,3)=nprecip(:,3)./10;      %convert Evap from [mm h-1] to [cm h-1]
             */
            mclArrayAssign2(
              &nprecip,
              mclRdivide(
                mclArrayRef2(
                  mclVv(nprecip, "nprecip"),
                  mlfCreateColonIndex(),
                  _mxarray72_),
                _mxarray70_),
              mlfCreateColonIndex(),
              _mxarray72_);
        /*
         * else
         */
        } else {
        /*
         * end
         */
        }
    /*
     * end
     */
    }
    /*
     * %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
     * %Run Modules
     * %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
     * if unit == 1
     */
    if (mclEqBool(mclVv(unit, "unit"), _mxarray0_)) {
        /*
         * [Dprecip,Dimp,Dperv,Drunon,Drunoff,Devap,Drecharge,Dudrain,Dstore,maxpond,tstponded,inot] = recarga(nprecip,Sd,avet,rundays,outname,Summary,Record,dmin,Srz,St,Rsoilnumber,Ssoilnumber,Nsoilnumber,Krz,Kst,Kcz,Urate,CN,EIA,Arg,TribA);
         */
        mlfAssign(
          &Dprecip,
          mlfRecarga(
            &Dimp,
            &Dperv,
            &Drunon,
            &Drunoff,
            &Devap,
            &Drecharge,
            &Dudrain,
            &Dstore,
            &maxpond,
            &tstponded,
            &inot,
            mclVv(nprecip, "nprecip"),
            mclVv(Sd, "Sd"),
            mclVv(avet, "avet"),
            mclVv(rundays, "rundays"),
            mclVv(outname, "outname"),
            mclVv(Summary, "Summary"),
            mclVv(Record, "Record"),
            mclVv(dmin, "dmin"),
            mclVv(Srz, "Srz"),
            mclVv(St, "St"),
            mclVv(Rsoilnumber, "Rsoilnumber"),
            mclVv(Ssoilnumber, "Ssoilnumber"),
            mclVv(Nsoilnumber, "Nsoilnumber"),
            mclVv(Krz, "Krz"),
            mclVv(Kst, "Kst"),
            mclVv(Kcz, "Kcz"),
            mclVv(Urate, "Urate"),
            mclVv(CN, "CN"),
            mclVv(EIA, "EIA"),
            mclVv(Arg, "Arg"),
            mclVv(TribA, "TribA")));
    /*
     * else
     */
    } else {
        /*
         * nprecip(:,2)=nprecip(:,2).*2.54; nprecip(:,3)=nprecip(:,3).*2.54;
         */
        mclArrayAssign2(
          &nprecip,
          mclTimes(
            mclArrayRef2(
              mclVv(nprecip, "nprecip"), mlfCreateColonIndex(), _mxarray42_),
            _mxarray85_),
          mlfCreateColonIndex(),
          _mxarray42_);
        mclArrayAssign2(
          &nprecip,
          mclTimes(
            mclArrayRef2(
              mclVv(nprecip, "nprecip"), mlfCreateColonIndex(), _mxarray72_),
            _mxarray85_),
          mlfCreateColonIndex(),
          _mxarray72_);
        /*
         * [Dprecip,Dimp,Dperv,Drunon,Drunoff,Devap,Drecharge,Dudrain,Dstore,maxpond,tstponded,inot] = recarga_us(nprecip,Sd,avet,rundays,outname,Summary,Record,dmin,Srz,St,Rsoilnumber,Ssoilnumber,Nsoilnumber,Krz,Kst,Kcz,Urate,CN,EIA,Arg,TribA);
         */
        mlfAssign(
          &Dprecip,
          mlfRecarga_us(
            &Dimp,
            &Dperv,
            &Drunon,
            &Drunoff,
            &Devap,
            &Drecharge,
            &Dudrain,
            &Dstore,
            &maxpond,
            &tstponded,
            &inot,
            mclVv(nprecip, "nprecip"),
            mclVv(Sd, "Sd"),
            mclVv(avet, "avet"),
            mclVv(rundays, "rundays"),
            mclVv(outname, "outname"),
            mclVv(Summary, "Summary"),
            mclVv(Record, "Record"),
            mclVv(dmin, "dmin"),
            mclVv(Srz, "Srz"),
            mclVv(St, "St"),
            mclVv(Rsoilnumber, "Rsoilnumber"),
            mclVv(Ssoilnumber, "Ssoilnumber"),
            mclVv(Nsoilnumber, "Nsoilnumber"),
            mclVv(Krz, "Krz"),
            mclVv(Kst, "Kst"),
            mclVv(Kcz, "Kcz"),
            mclVv(Urate, "Urate"),
            mclVv(CN, "CN"),
            mclVv(EIA, "EIA"),
            mclVv(Arg, "Arg"),
            mclVv(TribA, "TribA")));
    /*
     * end
     */
    }
    /*
     * Dstay = Dprecip - Drunoff- Dudrain;
     */
    mlfAssign(
      &Dstay,
      mclMinus(
        mclMinus(mclVv(Dprecip, "Dprecip"), mclVv(Drunoff, "Drunoff")),
        mclVv(Dudrain, "Dudrain")));
    /*
     * %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
     * %Display Results
     * %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
     * set(handles.Precharge,'String',num2str(100*Drecharge/Dprecip));
     */
    mclAssignAns(
      &ans,
      mlfNSet(
        0,
        mlfIndexRef(mclVa(handles, "handles"), ".Precharge"),
        _mxarray35_,
        mlfNum2str(
          mclMrdivide(
            mclMtimes(_mxarray37_, mclVv(Drecharge, "Drecharge")),
            mclVv(Dprecip, "Dprecip")),
          NULL),
        NULL));
    /*
     * set(handles.Prunon,'String',num2str(100*Drunon/Dprecip));
     */
    mclAssignAns(
      &ans,
      mlfNSet(
        0,
        mlfIndexRef(mclVa(handles, "handles"), ".Prunon"),
        _mxarray35_,
        mlfNum2str(
          mclMrdivide(
            mclMtimes(_mxarray37_, mclVv(Drunon, "Drunon")),
            mclVv(Dprecip, "Dprecip")),
          NULL),
        NULL));
    /*
     * set(handles.Prunoff,'String',num2str(100*Drunoff/Dprecip));
     */
    mclAssignAns(
      &ans,
      mlfNSet(
        0,
        mlfIndexRef(mclVa(handles, "handles"), ".Prunoff"),
        _mxarray35_,
        mlfNum2str(
          mclMrdivide(
            mclMtimes(_mxarray37_, mclVv(Drunoff, "Drunoff")),
            mclVv(Dprecip, "Dprecip")),
          NULL),
        NULL));
    /*
     * set(handles.RoffDpth,'String',num2str(Drunoff));
     */
    mclAssignAns(
      &ans,
      mlfNSet(
        0,
        mlfIndexRef(mclVa(handles, "handles"), ".RoffDpth"),
        _mxarray35_,
        mlfNum2str(mclVv(Drunoff, "Drunoff"), NULL),
        NULL));
    /*
     * set(handles.RnOnDpth,'String',num2str(Drunon));
     */
    mclAssignAns(
      &ans,
      mlfNSet(
        0,
        mlfIndexRef(mclVa(handles, "handles"), ".RnOnDpth"),
        _mxarray35_,
        mlfNum2str(mclVv(Drunon, "Drunon"), NULL),
        NULL));
    /*
     * set(handles.RchrgDpth,'String',num2str(Drecharge));
     */
    mclAssignAns(
      &ans,
      mlfNSet(
        0,
        mlfIndexRef(mclVa(handles, "handles"), ".RchrgDpth"),
        _mxarray35_,
        mlfNum2str(mclVv(Drecharge, "Drecharge"), NULL),
        NULL));
    /*
     * set(handles.EvapDpth,'String',num2str(Devap));
     */
    mclAssignAns(
      &ans,
      mlfNSet(
        0,
        mlfIndexRef(mclVa(handles, "handles"), ".EvapDpth"),
        _mxarray35_,
        mlfNum2str(mclVv(Devap, "Devap"), NULL),
        NULL));
    /*
     * set(handles.Pevap,'String',num2str(100*Devap/Dprecip));
     */
    mclAssignAns(
      &ans,
      mlfNSet(
        0,
        mlfIndexRef(mclVa(handles, "handles"), ".Pevap"),
        _mxarray35_,
        mlfNum2str(
          mclMrdivide(
            mclMtimes(_mxarray37_, mclVv(Devap, "Devap")),
            mclVv(Dprecip, "Dprecip")),
          NULL),
        NULL));
    /*
     * set(handles.maxpond,'String',num2str(maxpond));
     */
    mclAssignAns(
      &ans,
      mlfNSet(
        0,
        mlfIndexRef(mclVa(handles, "handles"), ".maxpond"),
        _mxarray35_,
        mlfNum2str(mclVv(maxpond, "maxpond"), NULL),
        NULL));
    /*
     * set(handles.OFtimes,'String',num2str(inot));
     */
    mclAssignAns(
      &ans,
      mlfNSet(
        0,
        mlfIndexRef(mclVa(handles, "handles"), ".OFtimes"),
        _mxarray35_,
        mlfNum2str(mclVv(inot, "inot"), NULL),
        NULL));
    /*
     * set(handles.tpond,'String',num2str(tstponded));
     */
    mclAssignAns(
      &ans,
      mlfNSet(
        0,
        mlfIndexRef(mclVa(handles, "handles"), ".tpond"),
        _mxarray35_,
        mlfNum2str(mclVv(tstponded, "tstponded"), NULL),
        NULL));
    /*
     * set(handles.ImpDpth,'String',num2str(Dimp));
     */
    mclAssignAns(
      &ans,
      mlfNSet(
        0,
        mlfIndexRef(mclVa(handles, "handles"), ".ImpDpth"),
        _mxarray35_,
        mlfNum2str(mclVv(Dimp, "Dimp"), NULL),
        NULL));
    /*
     * set(handles.PervDpth,'String',num2str(Dperv));
     */
    mclAssignAns(
      &ans,
      mlfNSet(
        0,
        mlfIndexRef(mclVa(handles, "handles"), ".PervDpth"),
        _mxarray35_,
        mlfNum2str(mclVv(Dperv, "Dperv"), NULL),
        NULL));
    /*
     * set(handles.UdDpth,'String',num2str(Dudrain));
     */
    mclAssignAns(
      &ans,
      mlfNSet(
        0,
        mlfIndexRef(mclVa(handles, "handles"), ".UdDpth"),
        _mxarray35_,
        mlfNum2str(mclVv(Dudrain, "Dudrain"), NULL),
        NULL));
    /*
     * set(handles.UdFrac,'String',num2str(100*Dudrain/Dprecip));
     */
    mclAssignAns(
      &ans,
      mlfNSet(
        0,
        mlfIndexRef(mclVa(handles, "handles"), ".UdFrac"),
        _mxarray35_,
        mlfNum2str(
          mclMrdivide(
            mclMtimes(_mxarray37_, mclVv(Dudrain, "Dudrain")),
            mclVv(Dprecip, "Dprecip")),
          NULL),
        NULL));
    /*
     * set(handles.SMdepth,'String',num2str(Dstore));
     */
    mclAssignAns(
      &ans,
      mlfNSet(
        0,
        mlfIndexRef(mclVa(handles, "handles"), ".SMdepth"),
        _mxarray35_,
        mlfNum2str(mclVv(Dstore, "Dstore"), NULL),
        NULL));
    /*
     * set(handles.SMpercent,'String',num2str(100*Dstore/Dprecip));
     */
    mclAssignAns(
      &ans,
      mlfNSet(
        0,
        mlfIndexRef(mclVa(handles, "handles"), ".SMpercent"),
        _mxarray35_,
        mlfNum2str(
          mclMrdivide(
            mclMtimes(_mxarray37_, mclVv(Dstore, "Dstore")),
            mclVv(Dprecip, "Dprecip")),
          NULL),
        NULL));
    /*
     * set(handles.StayDpth,'String',num2str(Dstay));
     */
    mclAssignAns(
      &ans,
      mlfNSet(
        0,
        mlfIndexRef(mclVa(handles, "handles"), ".StayDpth"),
        _mxarray35_,
        mlfNum2str(mclVv(Dstay, "Dstay"), NULL),
        NULL));
    /*
     * set(handles.Stayper,'String',num2str(100*Dstay/Dprecip));
     */
    mclAssignAns(
      &ans,
      mlfNSet(
        0,
        mlfIndexRef(mclVa(handles, "handles"), ".Stayper"),
        _mxarray35_,
        mlfNum2str(
          mclMrdivide(
            mclMtimes(_mxarray37_, mclVv(Dstay, "Dstay")),
            mclVv(Dprecip, "Dprecip")),
          NULL),
        NULL));
    /*
     * set(handles.precip,'String',num2str(Dprecip));
     */
    mclAssignAns(
      &ans,
      mlfNSet(
        0,
        mlfIndexRef(mclVa(handles, "handles"), ".precip"),
        _mxarray35_,
        mlfNum2str(mclVv(Dprecip, "Dprecip"), NULL),
        NULL));
    mxDestroyArray(unit);
    mxDestroyArray(EIA);
    mxDestroyArray(Arg);
    mxDestroyArray(TribA);
    mxDestroyArray(CN);
    mxDestroyArray(Sd);
    mxDestroyArray(avet);
    mxDestroyArray(soilsdata);
    mxDestroyArray(soilnames);
    mxDestroyArray(Nsoilnumber);
    mxDestroyArray(Rsoilnumber);
    mxDestroyArray(Ssoilnumber);
    mxDestroyArray(NTexture);
    mxDestroyArray(STexture);
    mxDestroyArray(RTexture);
    mxDestroyArray(dmin);
    mxDestroyArray(St);
    mxDestroyArray(Srz);
    mxDestroyArray(Scz);
    mxDestroyArray(Kcz);
    mxDestroyArray(Krz);
    mxDestroyArray(Kst);
    mxDestroyArray(Urate);
    mxDestroyArray(Umax);
    mxDestroyArray(HydroCalc);
    mxDestroyArray(rundays);
    mxDestroyArray(time);
    mxDestroyArray(dt);
    mxDestroyArray(stime);
    mxDestroyArray(outname);
    mxDestroyArray(Summary);
    mxDestroyArray(Record);
    mxDestroyArray(fileext);
    mxDestroyArray(filename);
    mxDestroyArray(infile);
    mxDestroyArray(nprecip);
    mxDestroyArray(PptType);
    mxDestroyArray(PptName);
    mxDestroyArray(PptDepth);
    mxDestroyArray(PptFile);
    mxDestroyArray(Dprecip);
    mxDestroyArray(Dimp);
    mxDestroyArray(Dperv);
    mxDestroyArray(Drunon);
    mxDestroyArray(Drunoff);
    mxDestroyArray(Devap);
    mxDestroyArray(Drecharge);
    mxDestroyArray(Dudrain);
    mxDestroyArray(Dstore);
    mxDestroyArray(maxpond);
    mxDestroyArray(tstponded);
    mxDestroyArray(inot);
    mxDestroyArray(Dstay);
    mxDestroyArray(ans);
    mxDestroyArray(handles);
    mxDestroyArray(eventdata);
    mxDestroyArray(hObject);
    mclSetCurrentLocalFunctionTable(save_local_function_table_);
    /*
     * %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
     * 
     * % --- Executes during object creation, after setting all properties.
     */
}

/*
 * The function "Mrecarga_2_3_Process_CreateFcn" is the implementation version
 * of the "recarga_2_3/Process_CreateFcn" M-function from file
 * "u:\final_recarga6\recarga\recarga_2_3.m" (lines 1370-1383). It contains the
 * actual compiled code for that M-function. It is a static function and must
 * only be called from one of the interface functions, appearing below.
 */
/*
 * function Process_CreateFcn(hObject, eventdata, handles)
 */
static void Mrecarga_2_3_Process_CreateFcn(mxArray * hObject,
                                           mxArray * eventdata,
                                           mxArray * handles) {
    mexLocalFunctionTable save_local_function_table_
      = mclSetCurrentLocalFunctionTable(&_local_function_table_recarga_2_3);
    mxArray * ans = NULL;
    mclCopyArray(&hObject);
    mclCopyArray(&eventdata);
    mclCopyArray(&handles);
    /*
     * % hObject    handle to Process (see GCBO)
     * % eventdata  reserved - to be defined in a future version of MATLAB
     * % handles    empty - handles not created until after all CreateFcns called
     * 
     * % Hint: edit controls usually have a white background on Windows.
     * %       See ISPC and COMPUTER.
     * if ispc
     */
    if (mlfTobool(mlfIspc())) {
        /*
         * set(hObject,'BackgroundColor','white');
         */
        mclAssignAns(
          &ans,
          mlfNSet(
            0, mclVa(hObject, "hObject"), _mxarray28_, _mxarray30_, NULL));
    /*
     * else
     */
    } else {
        /*
         * set(hObject,'BackgroundColor',get(0,'defaultUicontrolBackgroundColor'));
         */
        mclAssignAns(
          &ans,
          mlfNSet(
            0,
            mclVa(hObject, "hObject"),
            _mxarray28_,
            mlfNGet(1, _mxarray32_, _mxarray33_, NULL),
            NULL));
    /*
     * end
     */
    }
    mxDestroyArray(ans);
    mxDestroyArray(handles);
    mxDestroyArray(eventdata);
    mxDestroyArray(hObject);
    mclSetCurrentLocalFunctionTable(save_local_function_table_);
    /*
     * 
     */
}

/*
 * The function "Mrecarga_2_3_clear_Callback" is the implementation version of
 * the "recarga_2_3/clear_Callback" M-function from file
 * "u:\final_recarga6\recarga\recarga_2_3.m" (lines 1383-1409). It contains the
 * actual compiled code for that M-function. It is a static function and must
 * only be called from one of the interface functions, appearing below.
 */
/*
 * function clear_Callback(hObject, eventdata, handles)
 */
static void Mrecarga_2_3_clear_Callback(mxArray * hObject,
                                        mxArray * eventdata,
                                        mxArray * handles) {
    mexLocalFunctionTable save_local_function_table_
      = mclSetCurrentLocalFunctionTable(&_local_function_table_recarga_2_3);
    mxArray * ans = NULL;
    mclCopyArray(&hObject);
    mclCopyArray(&eventdata);
    mclCopyArray(&handles);
    /*
     * % hObject    handle to clear (see GCBO)
     * % eventdata  reserved - to be defined in a future version of MATLAB
     * % handles    structure with handles and user data (see GUIDATA)
     * set(handles.Precharge,'String','0');
     */
    mclAssignAns(
      &ans,
      mlfNSet(
        0,
        mlfIndexRef(mclVa(handles, "handles"), ".Precharge"),
        _mxarray35_,
        _mxarray86_,
        NULL));
    /*
     * set(handles.Prunon,'String','0');
     */
    mclAssignAns(
      &ans,
      mlfNSet(
        0,
        mlfIndexRef(mclVa(handles, "handles"), ".Prunon"),
        _mxarray35_,
        _mxarray86_,
        NULL));
    /*
     * set(handles.Prunoff,'String','0');
     */
    mclAssignAns(
      &ans,
      mlfNSet(
        0,
        mlfIndexRef(mclVa(handles, "handles"), ".Prunoff"),
        _mxarray35_,
        _mxarray86_,
        NULL));
    /*
     * set(handles.RoffDpth,'String','0');
     */
    mclAssignAns(
      &ans,
      mlfNSet(
        0,
        mlfIndexRef(mclVa(handles, "handles"), ".RoffDpth"),
        _mxarray35_,
        _mxarray86_,
        NULL));
    /*
     * set(handles.RnOnDpth,'String','0');
     */
    mclAssignAns(
      &ans,
      mlfNSet(
        0,
        mlfIndexRef(mclVa(handles, "handles"), ".RnOnDpth"),
        _mxarray35_,
        _mxarray86_,
        NULL));
    /*
     * set(handles.RchrgDpth,'String','0');
     */
    mclAssignAns(
      &ans,
      mlfNSet(
        0,
        mlfIndexRef(mclVa(handles, "handles"), ".RchrgDpth"),
        _mxarray35_,
        _mxarray86_,
        NULL));
    /*
     * set(handles.EvapDpth,'String','0');
     */
    mclAssignAns(
      &ans,
      mlfNSet(
        0,
        mlfIndexRef(mclVa(handles, "handles"), ".EvapDpth"),
        _mxarray35_,
        _mxarray86_,
        NULL));
    /*
     * set(handles.Pevap,'String','0');
     */
    mclAssignAns(
      &ans,
      mlfNSet(
        0,
        mlfIndexRef(mclVa(handles, "handles"), ".Pevap"),
        _mxarray35_,
        _mxarray86_,
        NULL));
    /*
     * set(handles.maxpond,'String','0');
     */
    mclAssignAns(
      &ans,
      mlfNSet(
        0,
        mlfIndexRef(mclVa(handles, "handles"), ".maxpond"),
        _mxarray35_,
        _mxarray86_,
        NULL));
    /*
     * set(handles.tpond,'String','0');
     */
    mclAssignAns(
      &ans,
      mlfNSet(
        0,
        mlfIndexRef(mclVa(handles, "handles"), ".tpond"),
        _mxarray35_,
        _mxarray86_,
        NULL));
    /*
     * set(handles.OFtimes,'String','0');
     */
    mclAssignAns(
      &ans,
      mlfNSet(
        0,
        mlfIndexRef(mclVa(handles, "handles"), ".OFtimes"),
        _mxarray35_,
        _mxarray86_,
        NULL));
    /*
     * set(handles.ImpDpth,'String','0');
     */
    mclAssignAns(
      &ans,
      mlfNSet(
        0,
        mlfIndexRef(mclVa(handles, "handles"), ".ImpDpth"),
        _mxarray35_,
        _mxarray86_,
        NULL));
    /*
     * set(handles.PervDpth,'String','0');
     */
    mclAssignAns(
      &ans,
      mlfNSet(
        0,
        mlfIndexRef(mclVa(handles, "handles"), ".PervDpth"),
        _mxarray35_,
        _mxarray86_,
        NULL));
    /*
     * set(handles.UdDpth,'String','0');
     */
    mclAssignAns(
      &ans,
      mlfNSet(
        0,
        mlfIndexRef(mclVa(handles, "handles"), ".UdDpth"),
        _mxarray35_,
        _mxarray86_,
        NULL));
    /*
     * set(handles.UdFrac,'String','0');
     */
    mclAssignAns(
      &ans,
      mlfNSet(
        0,
        mlfIndexRef(mclVa(handles, "handles"), ".UdFrac"),
        _mxarray35_,
        _mxarray86_,
        NULL));
    /*
     * set(handles.SMdepth,'String','0');
     */
    mclAssignAns(
      &ans,
      mlfNSet(
        0,
        mlfIndexRef(mclVa(handles, "handles"), ".SMdepth"),
        _mxarray35_,
        _mxarray86_,
        NULL));
    /*
     * set(handles.SMpercent,'String','0');
     */
    mclAssignAns(
      &ans,
      mlfNSet(
        0,
        mlfIndexRef(mclVa(handles, "handles"), ".SMpercent"),
        _mxarray35_,
        _mxarray86_,
        NULL));
    /*
     * set(handles.StayDpth,'String','0');
     */
    mclAssignAns(
      &ans,
      mlfNSet(
        0,
        mlfIndexRef(mclVa(handles, "handles"), ".StayDpth"),
        _mxarray35_,
        _mxarray86_,
        NULL));
    /*
     * set(handles.Stayper,'String','0');
     */
    mclAssignAns(
      &ans,
      mlfNSet(
        0,
        mlfIndexRef(mclVa(handles, "handles"), ".Stayper"),
        _mxarray35_,
        _mxarray86_,
        NULL));
    /*
     * set(handles.precip,'String','0');
     */
    mclAssignAns(
      &ans,
      mlfNSet(
        0,
        mlfIndexRef(mclVa(handles, "handles"), ".precip"),
        _mxarray35_,
        _mxarray86_,
        NULL));
    mxDestroyArray(ans);
    mxDestroyArray(handles);
    mxDestroyArray(eventdata);
    mxDestroyArray(hObject);
    mclSetCurrentLocalFunctionTable(save_local_function_table_);
    /*
     * 
     * % --- Executes during object creation, after setting all properties.
     */
}

/*
 * The function "Mrecarga_2_3_RootTexture_CreateFcn" is the implementation
 * version of the "recarga_2_3/RootTexture_CreateFcn" M-function from file
 * "u:\final_recarga6\recarga\recarga_2_3.m" (lines 1409-1424). It contains the
 * actual compiled code for that M-function. It is a static function and must
 * only be called from one of the interface functions, appearing below.
 */
/*
 * function RootTexture_CreateFcn(hObject, eventdata, handles)
 */
static void Mrecarga_2_3_RootTexture_CreateFcn(mxArray * hObject,
                                               mxArray * eventdata,
                                               mxArray * handles) {
    mexLocalFunctionTable save_local_function_table_
      = mclSetCurrentLocalFunctionTable(&_local_function_table_recarga_2_3);
    mxArray * ans = NULL;
    mclCopyArray(&hObject);
    mclCopyArray(&eventdata);
    mclCopyArray(&handles);
    /*
     * % hObject    handle to RootTexture (see GCBO)
     * % eventdata  reserved - to be defined in a future version of MATLAB
     * % handles    empty - handles not created until after all CreateFcns called
     * 
     * % Hint: listbox controls usually have a white background on Windows.
     * %       See ISPC and COMPUTER.
     * if ispc
     */
    if (mlfTobool(mlfIspc())) {
        /*
         * set(hObject,'BackgroundColor','white');
         */
        mclAssignAns(
          &ans,
          mlfNSet(
            0, mclVa(hObject, "hObject"), _mxarray28_, _mxarray30_, NULL));
    /*
     * else
     */
    } else {
        /*
         * set(hObject,'BackgroundColor',get(0,'defaultUicontrolBackgroundColor'));
         */
        mclAssignAns(
          &ans,
          mlfNSet(
            0,
            mclVa(hObject, "hObject"),
            _mxarray28_,
            mlfNGet(1, _mxarray32_, _mxarray33_, NULL),
            NULL));
    /*
     * end
     */
    }
    mxDestroyArray(ans);
    mxDestroyArray(handles);
    mxDestroyArray(eventdata);
    mxDestroyArray(hObject);
    mclSetCurrentLocalFunctionTable(save_local_function_table_);
    /*
     * 
     * 
     * % --- Executes on selection change in RootTexture.
     */
}

/*
 * The function "Mrecarga_2_3_RootTexture_Callback" is the implementation
 * version of the "recarga_2_3/RootTexture_Callback" M-function from file
 * "u:\final_recarga6\recarga\recarga_2_3.m" (lines 1424-1434). It contains the
 * actual compiled code for that M-function. It is a static function and must
 * only be called from one of the interface functions, appearing below.
 */
/*
 * function RootTexture_Callback(hObject, eventdata, handles)
 */
static void Mrecarga_2_3_RootTexture_Callback(mxArray * hObject,
                                              mxArray * eventdata,
                                              mxArray * handles) {
    mexLocalFunctionTable save_local_function_table_
      = mclSetCurrentLocalFunctionTable(&_local_function_table_recarga_2_3);
    mclCopyArray(&hObject);
    mclCopyArray(&eventdata);
    mclCopyArray(&handles);
    mxDestroyArray(handles);
    mxDestroyArray(eventdata);
    mxDestroyArray(hObject);
    mclSetCurrentLocalFunctionTable(save_local_function_table_);
    /*
     * % hObject    handle to RootTexture (see GCBO)
     * % eventdata  reserved - to be defined in a future version of MATLAB
     * % handles    structure with handles and user data (see GUIDATA)
     * 
     * % Hints: contents = get(hObject,'String') returns RootTexture contents as cell array
     * %        contents{get(hObject,'Value')} returns selected item from RootTexture
     * 
     * 
     * % --- Executes during object creation, after setting all properties.
     */
}

/*
 * The function "Mrecarga_2_3_StorageTexture_CreateFcn" is the implementation
 * version of the "recarga_2_3/StorageTexture_CreateFcn" M-function from file
 * "u:\final_recarga6\recarga\recarga_2_3.m" (lines 1434-1449). It contains the
 * actual compiled code for that M-function. It is a static function and must
 * only be called from one of the interface functions, appearing below.
 */
/*
 * function StorageTexture_CreateFcn(hObject, eventdata, handles)
 */
static void Mrecarga_2_3_StorageTexture_CreateFcn(mxArray * hObject,
                                                  mxArray * eventdata,
                                                  mxArray * handles) {
    mexLocalFunctionTable save_local_function_table_
      = mclSetCurrentLocalFunctionTable(&_local_function_table_recarga_2_3);
    mxArray * ans = NULL;
    mclCopyArray(&hObject);
    mclCopyArray(&eventdata);
    mclCopyArray(&handles);
    /*
     * % hObject    handle to StorageTexture (see GCBO)
     * % eventdata  reserved - to be defined in a future version of MATLAB
     * % handles    empty - handles not created until after all CreateFcns called
     * 
     * % Hint: listbox controls usually have a white background on Windows.
     * %       See ISPC and COMPUTER.
     * if ispc
     */
    if (mlfTobool(mlfIspc())) {
        /*
         * set(hObject,'BackgroundColor','white');
         */
        mclAssignAns(
          &ans,
          mlfNSet(
            0, mclVa(hObject, "hObject"), _mxarray28_, _mxarray30_, NULL));
    /*
     * else
     */
    } else {
        /*
         * set(hObject,'BackgroundColor',get(0,'defaultUicontrolBackgroundColor'));
         */
        mclAssignAns(
          &ans,
          mlfNSet(
            0,
            mclVa(hObject, "hObject"),
            _mxarray28_,
            mlfNGet(1, _mxarray32_, _mxarray33_, NULL),
            NULL));
    /*
     * end
     */
    }
    mxDestroyArray(ans);
    mxDestroyArray(handles);
    mxDestroyArray(eventdata);
    mxDestroyArray(hObject);
    mclSetCurrentLocalFunctionTable(save_local_function_table_);
    /*
     * 
     * 
     * % --- Executes on selection change in StorageTexture.
     */
}

/*
 * The function "Mrecarga_2_3_StorageTexture_Callback" is the implementation
 * version of the "recarga_2_3/StorageTexture_Callback" M-function from file
 * "u:\final_recarga6\recarga\recarga_2_3.m" (lines 1449-1459). It contains the
 * actual compiled code for that M-function. It is a static function and must
 * only be called from one of the interface functions, appearing below.
 */
/*
 * function StorageTexture_Callback(hObject, eventdata, handles)
 */
static void Mrecarga_2_3_StorageTexture_Callback(mxArray * hObject,
                                                 mxArray * eventdata,
                                                 mxArray * handles) {
    mexLocalFunctionTable save_local_function_table_
      = mclSetCurrentLocalFunctionTable(&_local_function_table_recarga_2_3);
    mclCopyArray(&hObject);
    mclCopyArray(&eventdata);
    mclCopyArray(&handles);
    mxDestroyArray(handles);
    mxDestroyArray(eventdata);
    mxDestroyArray(hObject);
    mclSetCurrentLocalFunctionTable(save_local_function_table_);
    /*
     * % hObject    handle to StorageTexture (see GCBO)
     * % eventdata  reserved - to be defined in a future version of MATLAB
     * % handles    structure with handles and user data (see GUIDATA)
     * 
     * % Hints: contents = get(hObject,'String') returns StorageTexture contents as cell array
     * %        contents{get(hObject,'Value')} returns selected item from StorageTexture
     * 
     * 
     * % --- Executes during object creation, after setting all properties.
     */
}

/*
 * The function "Mrecarga_2_3_NativeTexture_CreateFcn" is the implementation
 * version of the "recarga_2_3/NativeTexture_CreateFcn" M-function from file
 * "u:\final_recarga6\recarga\recarga_2_3.m" (lines 1459-1474). It contains the
 * actual compiled code for that M-function. It is a static function and must
 * only be called from one of the interface functions, appearing below.
 */
/*
 * function NativeTexture_CreateFcn(hObject, eventdata, handles)
 */
static void Mrecarga_2_3_NativeTexture_CreateFcn(mxArray * hObject,
                                                 mxArray * eventdata,
                                                 mxArray * handles) {
    mexLocalFunctionTable save_local_function_table_
      = mclSetCurrentLocalFunctionTable(&_local_function_table_recarga_2_3);
    mxArray * ans = NULL;
    mclCopyArray(&hObject);
    mclCopyArray(&eventdata);
    mclCopyArray(&handles);
    /*
     * % hObject    handle to NativeTexture (see GCBO)
     * % eventdata  reserved - to be defined in a future version of MATLAB
     * % handles    empty - handles not created until after all CreateFcns called
     * 
     * % Hint: listbox controls usually have a white background on Windows.
     * %       See ISPC and COMPUTER.
     * if ispc
     */
    if (mlfTobool(mlfIspc())) {
        /*
         * set(hObject,'BackgroundColor','white');
         */
        mclAssignAns(
          &ans,
          mlfNSet(
            0, mclVa(hObject, "hObject"), _mxarray28_, _mxarray30_, NULL));
    /*
     * else
     */
    } else {
        /*
         * set(hObject,'BackgroundColor',get(0,'defaultUicontrolBackgroundColor'));
         */
        mclAssignAns(
          &ans,
          mlfNSet(
            0,
            mclVa(hObject, "hObject"),
            _mxarray28_,
            mlfNGet(1, _mxarray32_, _mxarray33_, NULL),
            NULL));
    /*
     * end
     */
    }
    mxDestroyArray(ans);
    mxDestroyArray(handles);
    mxDestroyArray(eventdata);
    mxDestroyArray(hObject);
    mclSetCurrentLocalFunctionTable(save_local_function_table_);
    /*
     * 
     * 
     * % --- Executes on selection change in NativeTexture.
     */
}

/*
 * The function "Mrecarga_2_3_NativeTexture_Callback" is the implementation
 * version of the "recarga_2_3/NativeTexture_Callback" M-function from file
 * "u:\final_recarga6\recarga\recarga_2_3.m" (lines 1474-1493). It contains the
 * actual compiled code for that M-function. It is a static function and must
 * only be called from one of the interface functions, appearing below.
 */
/*
 * function NativeTexture_Callback(hObject, eventdata, handles)
 */
static void Mrecarga_2_3_NativeTexture_Callback(mxArray * hObject,
                                                mxArray * eventdata,
                                                mxArray * handles) {
    mexLocalFunctionTable save_local_function_table_
      = mclSetCurrentLocalFunctionTable(&_local_function_table_recarga_2_3);
    mxArray * ans = NULL;
    mxArray * soilnumber = NULL;
    mxArray * soilsdata = NULL;
    mxArray * unit = NULL;
    mclCopyArray(&hObject);
    mclCopyArray(&eventdata);
    mclCopyArray(&handles);
    /*
     * % hObject    handle to NativeTexture (see GCBO)
     * % eventdata  reserved - to be defined in a future version of MATLAB
     * % handles    structure with handles and user data (see GUIDATA)
     * 
     * % Hints: contents = get(hObject,'String') returns NativeTexture contents as cell array
     * %        contents{get(hObject,'Value')} returns selected item from NativeTexture
     * unit = get(handles.Units,'Value');
     */
    mlfAssign(
      &unit,
      mlfNGet(
        1,
        mlfIndexRef(mclVa(handles, "handles"), ".Units"), _mxarray44_, NULL));
    /*
     * if unit ==1
     */
    if (mclEqBool(mclVv(unit, "unit"), _mxarray0_)) {
        /*
         * soilsdata=dlmread('soilsDNR.txt','\t',[0 1 10 4]);
         */
        mlfAssign(
          &soilsdata,
          mlfDlmread(_mxarray51_, _mxarray53_, _mxarray55_, NULL, NULL));
    /*
     * else
     */
    } else {
        /*
         * soilsdata=dlmread('soilsUS.txt','\t',[0 1 10 4]);
         */
        mlfAssign(
          &soilsdata,
          mlfDlmread(_mxarray57_, _mxarray53_, _mxarray55_, NULL, NULL));
    /*
     * end
     */
    }
    /*
     * soilnumber = get(handles.NativeTexture,'Value');
     */
    mlfAssign(
      &soilnumber,
      mlfNGet(
        1,
        mlfIndexRef(mclVa(handles, "handles"), ".NativeTexture"),
        _mxarray44_,
        NULL));
    /*
     * set(handles.Ksat,'String',num2str(num2str(soilsdata(soilnumber,4))));
     */
    mclAssignAns(
      &ans,
      mlfNSet(
        0,
        mlfIndexRef(mclVa(handles, "handles"), ".Ksat"),
        _mxarray35_,
        mlfNum2str(
          mlfNum2str(
            mclArrayRef2(
              mclVv(soilsdata, "soilsdata"),
              mclVv(soilnumber, "soilnumber"),
              _mxarray88_),
            NULL),
          NULL),
        NULL));
    mxDestroyArray(unit);
    mxDestroyArray(soilsdata);
    mxDestroyArray(soilnumber);
    mxDestroyArray(ans);
    mxDestroyArray(handles);
    mxDestroyArray(eventdata);
    mxDestroyArray(hObject);
    mclSetCurrentLocalFunctionTable(save_local_function_table_);
    /*
     * 
     * 
     * 
     * % --- Executes during object creation, after setting all properties.
     */
}

/*
 * The function "Mrecarga_2_3_Kstore_CreateFcn" is the implementation version
 * of the "recarga_2_3/Kstore_CreateFcn" M-function from file
 * "u:\final_recarga6\recarga\recarga_2_3.m" (lines 1493-1508). It contains the
 * actual compiled code for that M-function. It is a static function and must
 * only be called from one of the interface functions, appearing below.
 */
/*
 * function Kstore_CreateFcn(hObject, eventdata, handles)
 */
static void Mrecarga_2_3_Kstore_CreateFcn(mxArray * hObject,
                                          mxArray * eventdata,
                                          mxArray * handles) {
    mexLocalFunctionTable save_local_function_table_
      = mclSetCurrentLocalFunctionTable(&_local_function_table_recarga_2_3);
    mxArray * ans = NULL;
    mclCopyArray(&hObject);
    mclCopyArray(&eventdata);
    mclCopyArray(&handles);
    /*
     * % hObject    handle to Kstore (see GCBO)
     * % eventdata  reserved - to be defined in a future version of MATLAB
     * % handles    empty - handles not created until after all CreateFcns called
     * 
     * % Hint: edit controls usually have a white background on Windows.
     * %       See ISPC and COMPUTER.
     * if ispc
     */
    if (mlfTobool(mlfIspc())) {
        /*
         * set(hObject,'BackgroundColor','white');
         */
        mclAssignAns(
          &ans,
          mlfNSet(
            0, mclVa(hObject, "hObject"), _mxarray28_, _mxarray30_, NULL));
    /*
     * else
     */
    } else {
        /*
         * set(hObject,'BackgroundColor',get(0,'defaultUicontrolBackgroundColor'));
         */
        mclAssignAns(
          &ans,
          mlfNSet(
            0,
            mclVa(hObject, "hObject"),
            _mxarray28_,
            mlfNGet(1, _mxarray32_, _mxarray33_, NULL),
            NULL));
    /*
     * end
     */
    }
    mxDestroyArray(ans);
    mxDestroyArray(handles);
    mxDestroyArray(eventdata);
    mxDestroyArray(hObject);
    mclSetCurrentLocalFunctionTable(save_local_function_table_);
    /*
     * 
     * 
     * 
     */
}

/*
 * The function "Mrecarga_2_3_Kstore_Callback" is the implementation version of
 * the "recarga_2_3/Kstore_Callback" M-function from file
 * "u:\final_recarga6\recarga\recarga_2_3.m" (lines 1508-1518). It contains the
 * actual compiled code for that M-function. It is a static function and must
 * only be called from one of the interface functions, appearing below.
 */
/*
 * function Kstore_Callback(hObject, eventdata, handles)
 */
static void Mrecarga_2_3_Kstore_Callback(mxArray * hObject,
                                         mxArray * eventdata,
                                         mxArray * handles) {
    mexLocalFunctionTable save_local_function_table_
      = mclSetCurrentLocalFunctionTable(&_local_function_table_recarga_2_3);
    mclCopyArray(&hObject);
    mclCopyArray(&eventdata);
    mclCopyArray(&handles);
    mxDestroyArray(handles);
    mxDestroyArray(eventdata);
    mxDestroyArray(hObject);
    mclSetCurrentLocalFunctionTable(save_local_function_table_);
    /*
     * % hObject    handle to Kstore (see GCBO)
     * % eventdata  reserved - to be defined in a future version of MATLAB
     * % handles    structure with handles and user data (see GUIDATA)
     * 
     * % Hints: get(hObject,'String') returns contents of Kstore as text
     * %        str2double(get(hObject,'String')) returns contents of Kstore as a double
     * 
     * 
     * % --- Executes during object creation, after setting all properties.
     */
}

/*
 * The function "Mrecarga_2_3_Kroot_CreateFcn" is the implementation version of
 * the "recarga_2_3/Kroot_CreateFcn" M-function from file
 * "u:\final_recarga6\recarga\recarga_2_3.m" (lines 1518-1533). It contains the
 * actual compiled code for that M-function. It is a static function and must
 * only be called from one of the interface functions, appearing below.
 */
/*
 * function Kroot_CreateFcn(hObject, eventdata, handles)
 */
static void Mrecarga_2_3_Kroot_CreateFcn(mxArray * hObject,
                                         mxArray * eventdata,
                                         mxArray * handles) {
    mexLocalFunctionTable save_local_function_table_
      = mclSetCurrentLocalFunctionTable(&_local_function_table_recarga_2_3);
    mxArray * ans = NULL;
    mclCopyArray(&hObject);
    mclCopyArray(&eventdata);
    mclCopyArray(&handles);
    /*
     * % hObject    handle to Kroot (see GCBO)
     * % eventdata  reserved - to be defined in a future version of MATLAB
     * % handles    empty - handles not created until after all CreateFcns called
     * 
     * % Hint: edit controls usually have a white background on Windows.
     * %       See ISPC and COMPUTER.
     * if ispc
     */
    if (mlfTobool(mlfIspc())) {
        /*
         * set(hObject,'BackgroundColor','white');
         */
        mclAssignAns(
          &ans,
          mlfNSet(
            0, mclVa(hObject, "hObject"), _mxarray28_, _mxarray30_, NULL));
    /*
     * else
     */
    } else {
        /*
         * set(hObject,'BackgroundColor',get(0,'defaultUicontrolBackgroundColor'));
         */
        mclAssignAns(
          &ans,
          mlfNSet(
            0,
            mclVa(hObject, "hObject"),
            _mxarray28_,
            mlfNGet(1, _mxarray32_, _mxarray33_, NULL),
            NULL));
    /*
     * end
     */
    }
    mxDestroyArray(ans);
    mxDestroyArray(handles);
    mxDestroyArray(eventdata);
    mxDestroyArray(hObject);
    mclSetCurrentLocalFunctionTable(save_local_function_table_);
    /*
     * 
     * 
     * 
     */
}

/*
 * The function "Mrecarga_2_3_Kroot_Callback" is the implementation version of
 * the "recarga_2_3/Kroot_Callback" M-function from file
 * "u:\final_recarga6\recarga\recarga_2_3.m" (lines 1533-1543). It contains the
 * actual compiled code for that M-function. It is a static function and must
 * only be called from one of the interface functions, appearing below.
 */
/*
 * function Kroot_Callback(hObject, eventdata, handles)
 */
static void Mrecarga_2_3_Kroot_Callback(mxArray * hObject,
                                        mxArray * eventdata,
                                        mxArray * handles) {
    mexLocalFunctionTable save_local_function_table_
      = mclSetCurrentLocalFunctionTable(&_local_function_table_recarga_2_3);
    mclCopyArray(&hObject);
    mclCopyArray(&eventdata);
    mclCopyArray(&handles);
    mxDestroyArray(handles);
    mxDestroyArray(eventdata);
    mxDestroyArray(hObject);
    mclSetCurrentLocalFunctionTable(save_local_function_table_);
    /*
     * % hObject    handle to Kroot (see GCBO)
     * % eventdata  reserved - to be defined in a future version of MATLAB
     * % handles    structure with handles and user data (see GUIDATA)
     * 
     * % Hints: get(hObject,'String') returns contents of Kroot as text
     * %        str2double(get(hObject,'String')) returns contents of Kroot as a double
     * 
     * 
     * % --- Executes on button press in pushbutton3.
     */
}

/*
 * The function "Mrecarga_2_3_pushbutton3_Callback" is the implementation
 * version of the "recarga_2_3/pushbutton3_Callback" M-function from file
 * "u:\final_recarga6\recarga\recarga_2_3.m" (lines 1543-1550). It contains the
 * actual compiled code for that M-function. It is a static function and must
 * only be called from one of the interface functions, appearing below.
 */
/*
 * function pushbutton3_Callback(hObject, eventdata, handles)
 */
static void Mrecarga_2_3_pushbutton3_Callback(mxArray * hObject,
                                              mxArray * eventdata,
                                              mxArray * handles) {
    mexLocalFunctionTable save_local_function_table_
      = mclSetCurrentLocalFunctionTable(&_local_function_table_recarga_2_3);
    mclCopyArray(&hObject);
    mclCopyArray(&eventdata);
    mclCopyArray(&handles);
    mxDestroyArray(handles);
    mxDestroyArray(eventdata);
    mxDestroyArray(hObject);
    mclSetCurrentLocalFunctionTable(save_local_function_table_);
    /*
     * % hObject    handle to pushbutton3 (see GCBO)
     * % eventdata  reserved - to be defined in a future version of MATLAB
     * % handles    structure with handles and user data (see GUIDATA)
     * 
     * 
     * % --- Executes during object creation, after setting all properties.
     */
}

/*
 * The function "Mrecarga_2_3_SMVol_CreateFcn" is the implementation version of
 * the "recarga_2_3/SMVol_CreateFcn" M-function from file
 * "u:\final_recarga6\recarga\recarga_2_3.m" (lines 1550-1565). It contains the
 * actual compiled code for that M-function. It is a static function and must
 * only be called from one of the interface functions, appearing below.
 */
/*
 * function SMVol_CreateFcn(hObject, eventdata, handles)
 */
static void Mrecarga_2_3_SMVol_CreateFcn(mxArray * hObject,
                                         mxArray * eventdata,
                                         mxArray * handles) {
    mexLocalFunctionTable save_local_function_table_
      = mclSetCurrentLocalFunctionTable(&_local_function_table_recarga_2_3);
    mxArray * ans = NULL;
    mclCopyArray(&hObject);
    mclCopyArray(&eventdata);
    mclCopyArray(&handles);
    /*
     * % hObject    handle to SMVol (see GCBO)
     * % eventdata  reserved - to be defined in a future version of MATLAB
     * % handles    empty - handles not created until after all CreateFcns called
     * 
     * % Hint: edit controls usually have a white background on Windows.
     * %       See ISPC and COMPUTER.
     * if ispc
     */
    if (mlfTobool(mlfIspc())) {
        /*
         * set(hObject,'BackgroundColor','white');
         */
        mclAssignAns(
          &ans,
          mlfNSet(
            0, mclVa(hObject, "hObject"), _mxarray28_, _mxarray30_, NULL));
    /*
     * else
     */
    } else {
        /*
         * set(hObject,'BackgroundColor',get(0,'defaultUicontrolBackgroundColor'));
         */
        mclAssignAns(
          &ans,
          mlfNSet(
            0,
            mclVa(hObject, "hObject"),
            _mxarray28_,
            mlfNGet(1, _mxarray32_, _mxarray33_, NULL),
            NULL));
    /*
     * end
     */
    }
    mxDestroyArray(ans);
    mxDestroyArray(handles);
    mxDestroyArray(eventdata);
    mxDestroyArray(hObject);
    mclSetCurrentLocalFunctionTable(save_local_function_table_);
    /*
     * 
     * 
     * 
     */
}

/*
 * The function "Mrecarga_2_3_SMVol_Callback" is the implementation version of
 * the "recarga_2_3/SMVol_Callback" M-function from file
 * "u:\final_recarga6\recarga\recarga_2_3.m" (lines 1565-1575). It contains the
 * actual compiled code for that M-function. It is a static function and must
 * only be called from one of the interface functions, appearing below.
 */
/*
 * function SMVol_Callback(hObject, eventdata, handles)
 */
static void Mrecarga_2_3_SMVol_Callback(mxArray * hObject,
                                        mxArray * eventdata,
                                        mxArray * handles) {
    mexLocalFunctionTable save_local_function_table_
      = mclSetCurrentLocalFunctionTable(&_local_function_table_recarga_2_3);
    mclCopyArray(&hObject);
    mclCopyArray(&eventdata);
    mclCopyArray(&handles);
    mxDestroyArray(handles);
    mxDestroyArray(eventdata);
    mxDestroyArray(hObject);
    mclSetCurrentLocalFunctionTable(save_local_function_table_);
    /*
     * % hObject    handle to SMVol (see GCBO)
     * % eventdata  reserved - to be defined in a future version of MATLAB
     * % handles    structure with handles and user data (see GUIDATA)
     * 
     * % Hints: get(hObject,'String') returns contents of SMVol as text
     * %        str2double(get(hObject,'String')) returns contents of SMVol as a double
     * 
     * 
     * % --- Executes during object creation, after setting all properties.
     */
}

/*
 * The function "Mrecarga_2_3_SMpercent_CreateFcn" is the implementation
 * version of the "recarga_2_3/SMpercent_CreateFcn" M-function from file
 * "u:\final_recarga6\recarga\recarga_2_3.m" (lines 1575-1590). It contains the
 * actual compiled code for that M-function. It is a static function and must
 * only be called from one of the interface functions, appearing below.
 */
/*
 * function SMpercent_CreateFcn(hObject, eventdata, handles)
 */
static void Mrecarga_2_3_SMpercent_CreateFcn(mxArray * hObject,
                                             mxArray * eventdata,
                                             mxArray * handles) {
    mexLocalFunctionTable save_local_function_table_
      = mclSetCurrentLocalFunctionTable(&_local_function_table_recarga_2_3);
    mxArray * ans = NULL;
    mclCopyArray(&hObject);
    mclCopyArray(&eventdata);
    mclCopyArray(&handles);
    /*
     * % hObject    handle to SMpercent (see GCBO)
     * % eventdata  reserved - to be defined in a future version of MATLAB
     * % handles    empty - handles not created until after all CreateFcns called
     * 
     * % Hint: edit controls usually have a white background on Windows.
     * %       See ISPC and COMPUTER.
     * if ispc
     */
    if (mlfTobool(mlfIspc())) {
        /*
         * set(hObject,'BackgroundColor','white');
         */
        mclAssignAns(
          &ans,
          mlfNSet(
            0, mclVa(hObject, "hObject"), _mxarray28_, _mxarray30_, NULL));
    /*
     * else
     */
    } else {
        /*
         * set(hObject,'BackgroundColor',get(0,'defaultUicontrolBackgroundColor'));
         */
        mclAssignAns(
          &ans,
          mlfNSet(
            0,
            mclVa(hObject, "hObject"),
            _mxarray28_,
            mlfNGet(1, _mxarray32_, _mxarray33_, NULL),
            NULL));
    /*
     * end
     */
    }
    mxDestroyArray(ans);
    mxDestroyArray(handles);
    mxDestroyArray(eventdata);
    mxDestroyArray(hObject);
    mclSetCurrentLocalFunctionTable(save_local_function_table_);
    /*
     * 
     * 
     * 
     */
}

/*
 * The function "Mrecarga_2_3_SMpercent_Callback" is the implementation version
 * of the "recarga_2_3/SMpercent_Callback" M-function from file
 * "u:\final_recarga6\recarga\recarga_2_3.m" (lines 1590-1600). It contains the
 * actual compiled code for that M-function. It is a static function and must
 * only be called from one of the interface functions, appearing below.
 */
/*
 * function SMpercent_Callback(hObject, eventdata, handles)
 */
static void Mrecarga_2_3_SMpercent_Callback(mxArray * hObject,
                                            mxArray * eventdata,
                                            mxArray * handles) {
    mexLocalFunctionTable save_local_function_table_
      = mclSetCurrentLocalFunctionTable(&_local_function_table_recarga_2_3);
    mclCopyArray(&hObject);
    mclCopyArray(&eventdata);
    mclCopyArray(&handles);
    mxDestroyArray(handles);
    mxDestroyArray(eventdata);
    mxDestroyArray(hObject);
    mclSetCurrentLocalFunctionTable(save_local_function_table_);
    /*
     * % hObject    handle to SMpercent (see GCBO)
     * % eventdata  reserved - to be defined in a future version of MATLAB
     * % handles    structure with handles and user data (see GUIDATA)
     * 
     * % Hints: get(hObject,'String') returns contents of SMpercent as text
     * %        str2double(get(hObject,'String')) returns contents of SMpercent as a double
     * 
     * 
     * % --- Executes during object creation, after setting all properties.
     */
}

/*
 * The function "Mrecarga_2_3_SMdepth_CreateFcn" is the implementation version
 * of the "recarga_2_3/SMdepth_CreateFcn" M-function from file
 * "u:\final_recarga6\recarga\recarga_2_3.m" (lines 1600-1615). It contains the
 * actual compiled code for that M-function. It is a static function and must
 * only be called from one of the interface functions, appearing below.
 */
/*
 * function SMdepth_CreateFcn(hObject, eventdata, handles)
 */
static void Mrecarga_2_3_SMdepth_CreateFcn(mxArray * hObject,
                                           mxArray * eventdata,
                                           mxArray * handles) {
    mexLocalFunctionTable save_local_function_table_
      = mclSetCurrentLocalFunctionTable(&_local_function_table_recarga_2_3);
    mxArray * ans = NULL;
    mclCopyArray(&hObject);
    mclCopyArray(&eventdata);
    mclCopyArray(&handles);
    /*
     * % hObject    handle to SMdepth (see GCBO)
     * % eventdata  reserved - to be defined in a future version of MATLAB
     * % handles    empty - handles not created until after all CreateFcns called
     * 
     * % Hint: edit controls usually have a white background on Windows.
     * %       See ISPC and COMPUTER.
     * if ispc
     */
    if (mlfTobool(mlfIspc())) {
        /*
         * set(hObject,'BackgroundColor','white');
         */
        mclAssignAns(
          &ans,
          mlfNSet(
            0, mclVa(hObject, "hObject"), _mxarray28_, _mxarray30_, NULL));
    /*
     * else
     */
    } else {
        /*
         * set(hObject,'BackgroundColor',get(0,'defaultUicontrolBackgroundColor'));
         */
        mclAssignAns(
          &ans,
          mlfNSet(
            0,
            mclVa(hObject, "hObject"),
            _mxarray28_,
            mlfNGet(1, _mxarray32_, _mxarray33_, NULL),
            NULL));
    /*
     * end
     */
    }
    mxDestroyArray(ans);
    mxDestroyArray(handles);
    mxDestroyArray(eventdata);
    mxDestroyArray(hObject);
    mclSetCurrentLocalFunctionTable(save_local_function_table_);
    /*
     * 
     * 
     * 
     */
}

/*
 * The function "Mrecarga_2_3_SMdepth_Callback" is the implementation version
 * of the "recarga_2_3/SMdepth_Callback" M-function from file
 * "u:\final_recarga6\recarga\recarga_2_3.m" (lines 1615-1625). It contains the
 * actual compiled code for that M-function. It is a static function and must
 * only be called from one of the interface functions, appearing below.
 */
/*
 * function SMdepth_Callback(hObject, eventdata, handles)
 */
static void Mrecarga_2_3_SMdepth_Callback(mxArray * hObject,
                                          mxArray * eventdata,
                                          mxArray * handles) {
    mexLocalFunctionTable save_local_function_table_
      = mclSetCurrentLocalFunctionTable(&_local_function_table_recarga_2_3);
    mclCopyArray(&hObject);
    mclCopyArray(&eventdata);
    mclCopyArray(&handles);
    mxDestroyArray(handles);
    mxDestroyArray(eventdata);
    mxDestroyArray(hObject);
    mclSetCurrentLocalFunctionTable(save_local_function_table_);
    /*
     * % hObject    handle to SMdepth (see GCBO)
     * % eventdata  reserved - to be defined in a future version of MATLAB
     * % handles    structure with handles and user data (see GUIDATA)
     * 
     * % Hints: get(hObject,'String') returns contents of SMdepth as text
     * %        str2double(get(hObject,'String')) returns contents of SMdepth as a double
     * 
     * 
     * % --------------------------------------------------------------------
     */
}

/*
 * The function "Mrecarga_2_3_Untitled_1_Callback" is the implementation
 * version of the "recarga_2_3/Untitled_1_Callback" M-function from file
 * "u:\final_recarga6\recarga\recarga_2_3.m" (lines 1625-1632). It contains the
 * actual compiled code for that M-function. It is a static function and must
 * only be called from one of the interface functions, appearing below.
 */
/*
 * function Untitled_1_Callback(hObject, eventdata, handles)
 */
static void Mrecarga_2_3_Untitled_1_Callback(mxArray * hObject,
                                             mxArray * eventdata,
                                             mxArray * handles) {
    mexLocalFunctionTable save_local_function_table_
      = mclSetCurrentLocalFunctionTable(&_local_function_table_recarga_2_3);
    mclCopyArray(&hObject);
    mclCopyArray(&eventdata);
    mclCopyArray(&handles);
    mxDestroyArray(handles);
    mxDestroyArray(eventdata);
    mxDestroyArray(hObject);
    mclSetCurrentLocalFunctionTable(save_local_function_table_);
    /*
     * % hObject    handle to Untitled_1 (see GCBO)
     * % eventdata  reserved - to be defined in a future version of MATLAB
     * % handles    structure with handles and user data (see GUIDATA)
     * 
     * 
     * % --------------------------------------------------------------------
     */
}

/*
 * The function "Mrecarga_2_3_Untitled_2_Callback" is the implementation
 * version of the "recarga_2_3/Untitled_2_Callback" M-function from file
 * "u:\final_recarga6\recarga\recarga_2_3.m" (lines 1632-1639). It contains the
 * actual compiled code for that M-function. It is a static function and must
 * only be called from one of the interface functions, appearing below.
 */
/*
 * function Untitled_2_Callback(hObject, eventdata, handles)
 */
static void Mrecarga_2_3_Untitled_2_Callback(mxArray * hObject,
                                             mxArray * eventdata,
                                             mxArray * handles) {
    mexLocalFunctionTable save_local_function_table_
      = mclSetCurrentLocalFunctionTable(&_local_function_table_recarga_2_3);
    mclCopyArray(&hObject);
    mclCopyArray(&eventdata);
    mclCopyArray(&handles);
    mxDestroyArray(handles);
    mxDestroyArray(eventdata);
    mxDestroyArray(hObject);
    mclSetCurrentLocalFunctionTable(save_local_function_table_);
    /*
     * % hObject    handle to Untitled_2 (see GCBO)
     * % eventdata  reserved - to be defined in a future version of MATLAB
     * % handles    structure with handles and user data (see GUIDATA)
     * 
     * 
     * % --- Executes during object creation, after setting all properties.
     */
}

/*
 * The function "Mrecarga_2_3_Stayper_CreateFcn" is the implementation version
 * of the "recarga_2_3/Stayper_CreateFcn" M-function from file
 * "u:\final_recarga6\recarga\recarga_2_3.m" (lines 1639-1654). It contains the
 * actual compiled code for that M-function. It is a static function and must
 * only be called from one of the interface functions, appearing below.
 */
/*
 * function Stayper_CreateFcn(hObject, eventdata, handles)
 */
static void Mrecarga_2_3_Stayper_CreateFcn(mxArray * hObject,
                                           mxArray * eventdata,
                                           mxArray * handles) {
    mexLocalFunctionTable save_local_function_table_
      = mclSetCurrentLocalFunctionTable(&_local_function_table_recarga_2_3);
    mxArray * ans = NULL;
    mclCopyArray(&hObject);
    mclCopyArray(&eventdata);
    mclCopyArray(&handles);
    /*
     * % hObject    handle to Stayper (see GCBO)
     * % eventdata  reserved - to be defined in a future version of MATLAB
     * % handles    empty - handles not created until after all CreateFcns called
     * 
     * % Hint: edit controls usually have a white background on Windows.
     * %       See ISPC and COMPUTER.
     * if ispc
     */
    if (mlfTobool(mlfIspc())) {
        /*
         * set(hObject,'BackgroundColor','white');
         */
        mclAssignAns(
          &ans,
          mlfNSet(
            0, mclVa(hObject, "hObject"), _mxarray28_, _mxarray30_, NULL));
    /*
     * else
     */
    } else {
        /*
         * set(hObject,'BackgroundColor',get(0,'defaultUicontrolBackgroundColor'));
         */
        mclAssignAns(
          &ans,
          mlfNSet(
            0,
            mclVa(hObject, "hObject"),
            _mxarray28_,
            mlfNGet(1, _mxarray32_, _mxarray33_, NULL),
            NULL));
    /*
     * end
     */
    }
    mxDestroyArray(ans);
    mxDestroyArray(handles);
    mxDestroyArray(eventdata);
    mxDestroyArray(hObject);
    mclSetCurrentLocalFunctionTable(save_local_function_table_);
    /*
     * 
     * 
     * 
     */
}

/*
 * The function "Mrecarga_2_3_Stayper_Callback" is the implementation version
 * of the "recarga_2_3/Stayper_Callback" M-function from file
 * "u:\final_recarga6\recarga\recarga_2_3.m" (lines 1654-1664). It contains the
 * actual compiled code for that M-function. It is a static function and must
 * only be called from one of the interface functions, appearing below.
 */
/*
 * function Stayper_Callback(hObject, eventdata, handles)
 */
static void Mrecarga_2_3_Stayper_Callback(mxArray * hObject,
                                          mxArray * eventdata,
                                          mxArray * handles) {
    mexLocalFunctionTable save_local_function_table_
      = mclSetCurrentLocalFunctionTable(&_local_function_table_recarga_2_3);
    mclCopyArray(&hObject);
    mclCopyArray(&eventdata);
    mclCopyArray(&handles);
    mxDestroyArray(handles);
    mxDestroyArray(eventdata);
    mxDestroyArray(hObject);
    mclSetCurrentLocalFunctionTable(save_local_function_table_);
    /*
     * % hObject    handle to Stayper (see GCBO)
     * % eventdata  reserved - to be defined in a future version of MATLAB
     * % handles    structure with handles and user data (see GUIDATA)
     * 
     * % Hints: get(hObject,'String') returns contents of Stayper as text
     * %        str2double(get(hObject,'String')) returns contents of Stayper as a double
     * 
     * 
     * % --- Executes during object creation, after setting all properties.
     */
}

/*
 * The function "Mrecarga_2_3_StayDpth_CreateFcn" is the implementation version
 * of the "recarga_2_3/StayDpth_CreateFcn" M-function from file
 * "u:\final_recarga6\recarga\recarga_2_3.m" (lines 1664-1679). It contains the
 * actual compiled code for that M-function. It is a static function and must
 * only be called from one of the interface functions, appearing below.
 */
/*
 * function StayDpth_CreateFcn(hObject, eventdata, handles)
 */
static void Mrecarga_2_3_StayDpth_CreateFcn(mxArray * hObject,
                                            mxArray * eventdata,
                                            mxArray * handles) {
    mexLocalFunctionTable save_local_function_table_
      = mclSetCurrentLocalFunctionTable(&_local_function_table_recarga_2_3);
    mxArray * ans = NULL;
    mclCopyArray(&hObject);
    mclCopyArray(&eventdata);
    mclCopyArray(&handles);
    /*
     * % hObject    handle to StayDpth (see GCBO)
     * % eventdata  reserved - to be defined in a future version of MATLAB
     * % handles    empty - handles not created until after all CreateFcns called
     * 
     * % Hint: edit controls usually have a white background on Windows.
     * %       See ISPC and COMPUTER.
     * if ispc
     */
    if (mlfTobool(mlfIspc())) {
        /*
         * set(hObject,'BackgroundColor','white');
         */
        mclAssignAns(
          &ans,
          mlfNSet(
            0, mclVa(hObject, "hObject"), _mxarray28_, _mxarray30_, NULL));
    /*
     * else
     */
    } else {
        /*
         * set(hObject,'BackgroundColor',get(0,'defaultUicontrolBackgroundColor'));
         */
        mclAssignAns(
          &ans,
          mlfNSet(
            0,
            mclVa(hObject, "hObject"),
            _mxarray28_,
            mlfNGet(1, _mxarray32_, _mxarray33_, NULL),
            NULL));
    /*
     * end
     */
    }
    mxDestroyArray(ans);
    mxDestroyArray(handles);
    mxDestroyArray(eventdata);
    mxDestroyArray(hObject);
    mclSetCurrentLocalFunctionTable(save_local_function_table_);
    /*
     * 
     * 
     * 
     */
}

/*
 * The function "Mrecarga_2_3_StayDpth_Callback" is the implementation version
 * of the "recarga_2_3/StayDpth_Callback" M-function from file
 * "u:\final_recarga6\recarga\recarga_2_3.m" (lines 1679-1689). It contains the
 * actual compiled code for that M-function. It is a static function and must
 * only be called from one of the interface functions, appearing below.
 */
/*
 * function StayDpth_Callback(hObject, eventdata, handles)
 */
static void Mrecarga_2_3_StayDpth_Callback(mxArray * hObject,
                                           mxArray * eventdata,
                                           mxArray * handles) {
    mexLocalFunctionTable save_local_function_table_
      = mclSetCurrentLocalFunctionTable(&_local_function_table_recarga_2_3);
    mclCopyArray(&hObject);
    mclCopyArray(&eventdata);
    mclCopyArray(&handles);
    mxDestroyArray(handles);
    mxDestroyArray(eventdata);
    mxDestroyArray(hObject);
    mclSetCurrentLocalFunctionTable(save_local_function_table_);
    /*
     * % hObject    handle to StayDpth (see GCBO)
     * % eventdata  reserved - to be defined in a future version of MATLAB
     * % handles    structure with handles and user data (see GUIDATA)
     * 
     * % Hints: get(hObject,'String') returns contents of StayDpth as text
     * %        str2double(get(hObject,'String')) returns contents of StayDpth as a double
     * 
     * 
     * % --- Executes on button press in Summary.
     */
}

/*
 * The function "Mrecarga_2_3_Summary_Callback" is the implementation version
 * of the "recarga_2_3/Summary_Callback" M-function from file
 * "u:\final_recarga6\recarga\recarga_2_3.m" (lines 1689-1698). It contains the
 * actual compiled code for that M-function. It is a static function and must
 * only be called from one of the interface functions, appearing below.
 */
/*
 * function Summary_Callback(hObject, eventdata, handles)
 */
static void Mrecarga_2_3_Summary_Callback(mxArray * hObject,
                                          mxArray * eventdata,
                                          mxArray * handles) {
    mexLocalFunctionTable save_local_function_table_
      = mclSetCurrentLocalFunctionTable(&_local_function_table_recarga_2_3);
    mclCopyArray(&hObject);
    mclCopyArray(&eventdata);
    mclCopyArray(&handles);
    mxDestroyArray(handles);
    mxDestroyArray(eventdata);
    mxDestroyArray(hObject);
    mclSetCurrentLocalFunctionTable(save_local_function_table_);
    /*
     * % hObject    handle to Summary (see GCBO)
     * % eventdata  reserved - to be defined in a future version of MATLAB
     * % handles    structure with handles and user data (see GUIDATA)
     * 
     * % Hint: get(hObject,'Value') returns toggle state of Summary
     * 
     * 
     * % --- Executes on button press in Record.
     */
}

/*
 * The function "Mrecarga_2_3_Record_Callback" is the implementation version of
 * the "recarga_2_3/Record_Callback" M-function from file
 * "u:\final_recarga6\recarga\recarga_2_3.m" (lines 1698-1707). It contains the
 * actual compiled code for that M-function. It is a static function and must
 * only be called from one of the interface functions, appearing below.
 */
/*
 * function Record_Callback(hObject, eventdata, handles)
 */
static void Mrecarga_2_3_Record_Callback(mxArray * hObject,
                                         mxArray * eventdata,
                                         mxArray * handles) {
    mexLocalFunctionTable save_local_function_table_
      = mclSetCurrentLocalFunctionTable(&_local_function_table_recarga_2_3);
    mclCopyArray(&hObject);
    mclCopyArray(&eventdata);
    mclCopyArray(&handles);
    mxDestroyArray(handles);
    mxDestroyArray(eventdata);
    mxDestroyArray(hObject);
    mclSetCurrentLocalFunctionTable(save_local_function_table_);
    /*
     * % hObject    handle to Record (see GCBO)
     * % eventdata  reserved - to be defined in a future version of MATLAB
     * % handles    structure with handles and user data (see GUIDATA)
     * 
     * % Hint: get(hObject,'Value') returns toggle state of Record
     * 
     * 
     * % --- Executes during object creation, after setting all properties.
     */
}

/*
 * The function "Mrecarga_2_3_edit67_CreateFcn" is the implementation version
 * of the "recarga_2_3/edit67_CreateFcn" M-function from file
 * "u:\final_recarga6\recarga\recarga_2_3.m" (lines 1707-1722). It contains the
 * actual compiled code for that M-function. It is a static function and must
 * only be called from one of the interface functions, appearing below.
 */
/*
 * function edit67_CreateFcn(hObject, eventdata, handles)
 */
static void Mrecarga_2_3_edit67_CreateFcn(mxArray * hObject,
                                          mxArray * eventdata,
                                          mxArray * handles) {
    mexLocalFunctionTable save_local_function_table_
      = mclSetCurrentLocalFunctionTable(&_local_function_table_recarga_2_3);
    mxArray * ans = NULL;
    mclCopyArray(&hObject);
    mclCopyArray(&eventdata);
    mclCopyArray(&handles);
    /*
     * % hObject    handle to edit67 (see GCBO)
     * % eventdata  reserved - to be defined in a future version of MATLAB
     * % handles    empty - handles not created until after all CreateFcns called
     * 
     * % Hint: edit controls usually have a white background on Windows.
     * %       See ISPC and COMPUTER.
     * if ispc
     */
    if (mlfTobool(mlfIspc())) {
        /*
         * set(hObject,'BackgroundColor','white');
         */
        mclAssignAns(
          &ans,
          mlfNSet(
            0, mclVa(hObject, "hObject"), _mxarray28_, _mxarray30_, NULL));
    /*
     * else
     */
    } else {
        /*
         * set(hObject,'BackgroundColor',get(0,'defaultUicontrolBackgroundColor'));
         */
        mclAssignAns(
          &ans,
          mlfNSet(
            0,
            mclVa(hObject, "hObject"),
            _mxarray28_,
            mlfNGet(1, _mxarray32_, _mxarray33_, NULL),
            NULL));
    /*
     * end
     */
    }
    mxDestroyArray(ans);
    mxDestroyArray(handles);
    mxDestroyArray(eventdata);
    mxDestroyArray(hObject);
    mclSetCurrentLocalFunctionTable(save_local_function_table_);
    /*
     * 
     * 
     * 
     */
}

/*
 * The function "Mrecarga_2_3_edit67_Callback" is the implementation version of
 * the "recarga_2_3/edit67_Callback" M-function from file
 * "u:\final_recarga6\recarga\recarga_2_3.m" (lines 1722-1732). It contains the
 * actual compiled code for that M-function. It is a static function and must
 * only be called from one of the interface functions, appearing below.
 */
/*
 * function edit67_Callback(hObject, eventdata, handles)
 */
static void Mrecarga_2_3_edit67_Callback(mxArray * hObject,
                                         mxArray * eventdata,
                                         mxArray * handles) {
    mexLocalFunctionTable save_local_function_table_
      = mclSetCurrentLocalFunctionTable(&_local_function_table_recarga_2_3);
    mclCopyArray(&hObject);
    mclCopyArray(&eventdata);
    mclCopyArray(&handles);
    mxDestroyArray(handles);
    mxDestroyArray(eventdata);
    mxDestroyArray(hObject);
    mclSetCurrentLocalFunctionTable(save_local_function_table_);
    /*
     * % hObject    handle to edit67 (see GCBO)
     * % eventdata  reserved - to be defined in a future version of MATLAB
     * % handles    structure with handles and user data (see GUIDATA)
     * 
     * % Hints: get(hObject,'String') returns contents of edit67 as text
     * %        str2double(get(hObject,'String')) returns contents of edit67 as a double
     * 
     * 
     * % --- Executes during object creation, after setting all properties.
     */
}

/*
 * The function "Mrecarga_2_3_precip_CreateFcn" is the implementation version
 * of the "recarga_2_3/precip_CreateFcn" M-function from file
 * "u:\final_recarga6\recarga\recarga_2_3.m" (lines 1732-1747). It contains the
 * actual compiled code for that M-function. It is a static function and must
 * only be called from one of the interface functions, appearing below.
 */
/*
 * function precip_CreateFcn(hObject, eventdata, handles)
 */
static void Mrecarga_2_3_precip_CreateFcn(mxArray * hObject,
                                          mxArray * eventdata,
                                          mxArray * handles) {
    mexLocalFunctionTable save_local_function_table_
      = mclSetCurrentLocalFunctionTable(&_local_function_table_recarga_2_3);
    mxArray * ans = NULL;
    mclCopyArray(&hObject);
    mclCopyArray(&eventdata);
    mclCopyArray(&handles);
    /*
     * % hObject    handle to precip (see GCBO)
     * % eventdata  reserved - to be defined in a future version of MATLAB
     * % handles    empty - handles not created until after all CreateFcns called
     * 
     * % Hint: edit controls usually have a white background on Windows.
     * %       See ISPC and COMPUTER.
     * if ispc
     */
    if (mlfTobool(mlfIspc())) {
        /*
         * set(hObject,'BackgroundColor','white');
         */
        mclAssignAns(
          &ans,
          mlfNSet(
            0, mclVa(hObject, "hObject"), _mxarray28_, _mxarray30_, NULL));
    /*
     * else
     */
    } else {
        /*
         * set(hObject,'BackgroundColor',get(0,'defaultUicontrolBackgroundColor'));
         */
        mclAssignAns(
          &ans,
          mlfNSet(
            0,
            mclVa(hObject, "hObject"),
            _mxarray28_,
            mlfNGet(1, _mxarray32_, _mxarray33_, NULL),
            NULL));
    /*
     * end
     */
    }
    mxDestroyArray(ans);
    mxDestroyArray(handles);
    mxDestroyArray(eventdata);
    mxDestroyArray(hObject);
    mclSetCurrentLocalFunctionTable(save_local_function_table_);
    /*
     * 
     * 
     * 
     */
}

/*
 * The function "Mrecarga_2_3_precip_Callback" is the implementation version of
 * the "recarga_2_3/precip_Callback" M-function from file
 * "u:\final_recarga6\recarga\recarga_2_3.m" (lines 1747-1757). It contains the
 * actual compiled code for that M-function. It is a static function and must
 * only be called from one of the interface functions, appearing below.
 */
/*
 * function precip_Callback(hObject, eventdata, handles)
 */
static void Mrecarga_2_3_precip_Callback(mxArray * hObject,
                                         mxArray * eventdata,
                                         mxArray * handles) {
    mexLocalFunctionTable save_local_function_table_
      = mclSetCurrentLocalFunctionTable(&_local_function_table_recarga_2_3);
    mclCopyArray(&hObject);
    mclCopyArray(&eventdata);
    mclCopyArray(&handles);
    mxDestroyArray(handles);
    mxDestroyArray(eventdata);
    mxDestroyArray(hObject);
    mclSetCurrentLocalFunctionTable(save_local_function_table_);
    /*
     * % hObject    handle to precip (see GCBO)
     * % eventdata  reserved - to be defined in a future version of MATLAB
     * % handles    structure with handles and user data (see GUIDATA)
     * 
     * % Hints: get(hObject,'String') returns contents of precip as text
     * %        str2double(get(hObject,'String')) returns contents of precip as a double
     * 
     * 
     * % --- Executes during object creation, after setting all properties.
     */
}

/*
 * The function "Mrecarga_2_3_SimType_CreateFcn" is the implementation version
 * of the "recarga_2_3/SimType_CreateFcn" M-function from file
 * "u:\final_recarga6\recarga\recarga_2_3.m" (lines 1757-1772). It contains the
 * actual compiled code for that M-function. It is a static function and must
 * only be called from one of the interface functions, appearing below.
 */
/*
 * function SimType_CreateFcn(hObject, eventdata, handles)
 */
static void Mrecarga_2_3_SimType_CreateFcn(mxArray * hObject,
                                           mxArray * eventdata,
                                           mxArray * handles) {
    mexLocalFunctionTable save_local_function_table_
      = mclSetCurrentLocalFunctionTable(&_local_function_table_recarga_2_3);
    mxArray * ans = NULL;
    mclCopyArray(&hObject);
    mclCopyArray(&eventdata);
    mclCopyArray(&handles);
    /*
     * % hObject    handle to SimType (see GCBO)
     * % eventdata  reserved - to be defined in a future version of MATLAB
     * % handles    empty - handles not created until after all CreateFcns called
     * 
     * % Hint: popupmenu controls usually have a white background on Windows.
     * %       See ISPC and COMPUTER.
     * if ispc
     */
    if (mlfTobool(mlfIspc())) {
        /*
         * set(hObject,'BackgroundColor','white');
         */
        mclAssignAns(
          &ans,
          mlfNSet(
            0, mclVa(hObject, "hObject"), _mxarray28_, _mxarray30_, NULL));
    /*
     * else
     */
    } else {
        /*
         * set(hObject,'BackgroundColor',get(0,'defaultUicontrolBackgroundColor'));
         */
        mclAssignAns(
          &ans,
          mlfNSet(
            0,
            mclVa(hObject, "hObject"),
            _mxarray28_,
            mlfNGet(1, _mxarray32_, _mxarray33_, NULL),
            NULL));
    /*
     * end
     */
    }
    mxDestroyArray(ans);
    mxDestroyArray(handles);
    mxDestroyArray(eventdata);
    mxDestroyArray(hObject);
    mclSetCurrentLocalFunctionTable(save_local_function_table_);
    /*
     * 
     * 
     * % --- Executes on selection change in SimType.
     */
}

/*
 * The function "Mrecarga_2_3_SimType_Callback" is the implementation version
 * of the "recarga_2_3/SimType_Callback" M-function from file
 * "u:\final_recarga6\recarga\recarga_2_3.m" (lines 1772-1795). It contains the
 * actual compiled code for that M-function. It is a static function and must
 * only be called from one of the interface functions, appearing below.
 */
/*
 * function SimType_Callback(hObject, eventdata, handles)
 */
static void Mrecarga_2_3_SimType_Callback(mxArray * hObject,
                                          mxArray * eventdata,
                                          mxArray * handles) {
    mexLocalFunctionTable save_local_function_table_
      = mclSetCurrentLocalFunctionTable(&_local_function_table_recarga_2_3);
    mxArray * ans = NULL;
    mxArray * Type = NULL;
    mclCopyArray(&hObject);
    mclCopyArray(&eventdata);
    mclCopyArray(&handles);
    /*
     * % hObject    handle to SimType (see GCBO)
     * % eventdata  reserved - to be defined in a future version of MATLAB
     * % handles    structure with handles and user data (see GUIDATA)
     * 
     * % Hints: contents = get(hObject,'String') returns SimType contents as cell array
     * %        contents{get(hObject,'Value')} returns selected item from SimType
     * Type = get(handles.SimType,'Value');
     */
    mlfAssign(
      &Type,
      mlfNGet(
        1,
        mlfIndexRef(mclVa(handles, "handles"), ".SimType"), _mxarray44_, NULL));
    /*
     * if Type == 2
     */
    if (mclEqBool(mclVv(Type, "Type"), _mxarray42_)) {
        /*
         * set(handles.PptType,'Visible','on'); set(handles.PptDepth,'Visible','on');; 
         */
        mclAssignAns(
          &ans,
          mlfNSet(
            0,
            mlfIndexRef(mclVa(handles, "handles"), ".PptType"),
            _mxarray22_,
            _mxarray89_,
            NULL));
        mclAssignAns(
          &ans,
          mlfNSet(
            0,
            mlfIndexRef(mclVa(handles, "handles"), ".PptDepth"),
            _mxarray22_,
            _mxarray89_,
            NULL));
        /*
         * set(handles.DepthLabel,'Visible','on');; set(handles.DistLabel,'Visible','on');;
         */
        mclAssignAns(
          &ans,
          mlfNSet(
            0,
            mlfIndexRef(mclVa(handles, "handles"), ".DepthLabel"),
            _mxarray22_,
            _mxarray89_,
            NULL));
        mclAssignAns(
          &ans,
          mlfNSet(
            0,
            mlfIndexRef(mclVa(handles, "handles"), ".DistLabel"),
            _mxarray22_,
            _mxarray89_,
            NULL));
        /*
         * set(handles.PrecipLabel,'Visible','off');; set(handles.Input,'Visible','off');
         */
        mclAssignAns(
          &ans,
          mlfNSet(
            0,
            mlfIndexRef(mclVa(handles, "handles"), ".PrecipLabel"),
            _mxarray22_,
            _mxarray24_,
            NULL));
        mclAssignAns(
          &ans,
          mlfNSet(
            0,
            mlfIndexRef(mclVa(handles, "handles"), ".Input"),
            _mxarray22_,
            _mxarray24_,
            NULL));
        /*
         * set(handles.LengthLabel,'Visible','off'); set(handles.Length,'Visible','off');
         */
        mclAssignAns(
          &ans,
          mlfNSet(
            0,
            mlfIndexRef(mclVa(handles, "handles"), ".LengthLabel"),
            _mxarray22_,
            _mxarray24_,
            NULL));
        mclAssignAns(
          &ans,
          mlfNSet(
            0,
            mlfIndexRef(mclVa(handles, "handles"), ".Length"),
            _mxarray22_,
            _mxarray24_,
            NULL));
    /*
     * else
     */
    } else {
        /*
         * set(handles.PptType,'Visible','off'); set(handles.PptDepth,'Visible','off'); 
         */
        mclAssignAns(
          &ans,
          mlfNSet(
            0,
            mlfIndexRef(mclVa(handles, "handles"), ".PptType"),
            _mxarray22_,
            _mxarray24_,
            NULL));
        mclAssignAns(
          &ans,
          mlfNSet(
            0,
            mlfIndexRef(mclVa(handles, "handles"), ".PptDepth"),
            _mxarray22_,
            _mxarray24_,
            NULL));
        /*
         * set(handles.DepthLabel,'Visible','off'); set(handles.DistLabel,'Visible','off');
         */
        mclAssignAns(
          &ans,
          mlfNSet(
            0,
            mlfIndexRef(mclVa(handles, "handles"), ".DepthLabel"),
            _mxarray22_,
            _mxarray24_,
            NULL));
        mclAssignAns(
          &ans,
          mlfNSet(
            0,
            mlfIndexRef(mclVa(handles, "handles"), ".DistLabel"),
            _mxarray22_,
            _mxarray24_,
            NULL));
        /*
         * set(handles.PrecipLabel,'Visible','on'); set(handles.Input,'Visible','on');
         */
        mclAssignAns(
          &ans,
          mlfNSet(
            0,
            mlfIndexRef(mclVa(handles, "handles"), ".PrecipLabel"),
            _mxarray22_,
            _mxarray89_,
            NULL));
        mclAssignAns(
          &ans,
          mlfNSet(
            0,
            mlfIndexRef(mclVa(handles, "handles"), ".Input"),
            _mxarray22_,
            _mxarray89_,
            NULL));
        /*
         * set(handles.LengthLabel,'Visible','on'); set(handles.Length,'Visible','on');    
         */
        mclAssignAns(
          &ans,
          mlfNSet(
            0,
            mlfIndexRef(mclVa(handles, "handles"), ".LengthLabel"),
            _mxarray22_,
            _mxarray89_,
            NULL));
        mclAssignAns(
          &ans,
          mlfNSet(
            0,
            mlfIndexRef(mclVa(handles, "handles"), ".Length"),
            _mxarray22_,
            _mxarray89_,
            NULL));
    /*
     * end
     */
    }
    mxDestroyArray(Type);
    mxDestroyArray(ans);
    mxDestroyArray(handles);
    mxDestroyArray(eventdata);
    mxDestroyArray(hObject);
    mclSetCurrentLocalFunctionTable(save_local_function_table_);
    /*
     * 
     * 
     * 
     * % --- Executes during object creation, after setting all properties.
     */
}

/*
 * The function "Mrecarga_2_3_PptType_CreateFcn" is the implementation version
 * of the "recarga_2_3/PptType_CreateFcn" M-function from file
 * "u:\final_recarga6\recarga\recarga_2_3.m" (lines 1795-1810). It contains the
 * actual compiled code for that M-function. It is a static function and must
 * only be called from one of the interface functions, appearing below.
 */
/*
 * function PptType_CreateFcn(hObject, eventdata, handles)
 */
static void Mrecarga_2_3_PptType_CreateFcn(mxArray * hObject,
                                           mxArray * eventdata,
                                           mxArray * handles) {
    mexLocalFunctionTable save_local_function_table_
      = mclSetCurrentLocalFunctionTable(&_local_function_table_recarga_2_3);
    mxArray * ans = NULL;
    mclCopyArray(&hObject);
    mclCopyArray(&eventdata);
    mclCopyArray(&handles);
    /*
     * % hObject    handle to PptType (see GCBO)
     * % eventdata  reserved - to be defined in a future version of MATLAB
     * % handles    empty - handles not created until after all CreateFcns called
     * 
     * % Hint: popupmenu controls usually have a white background on Windows.
     * %       See ISPC and COMPUTER.
     * if ispc
     */
    if (mlfTobool(mlfIspc())) {
        /*
         * set(hObject,'BackgroundColor','white');
         */
        mclAssignAns(
          &ans,
          mlfNSet(
            0, mclVa(hObject, "hObject"), _mxarray28_, _mxarray30_, NULL));
    /*
     * else
     */
    } else {
        /*
         * set(hObject,'BackgroundColor',get(0,'defaultUicontrolBackgroundColor'));
         */
        mclAssignAns(
          &ans,
          mlfNSet(
            0,
            mclVa(hObject, "hObject"),
            _mxarray28_,
            mlfNGet(1, _mxarray32_, _mxarray33_, NULL),
            NULL));
    /*
     * end
     */
    }
    mxDestroyArray(ans);
    mxDestroyArray(handles);
    mxDestroyArray(eventdata);
    mxDestroyArray(hObject);
    mclSetCurrentLocalFunctionTable(save_local_function_table_);
    /*
     * 
     * 
     * % --- Executes on selection change in PptType.
     */
}

/*
 * The function "Mrecarga_2_3_PptType_Callback" is the implementation version
 * of the "recarga_2_3/PptType_Callback" M-function from file
 * "u:\final_recarga6\recarga\recarga_2_3.m" (lines 1810-1820). It contains the
 * actual compiled code for that M-function. It is a static function and must
 * only be called from one of the interface functions, appearing below.
 */
/*
 * function PptType_Callback(hObject, eventdata, handles)
 */
static void Mrecarga_2_3_PptType_Callback(mxArray * hObject,
                                          mxArray * eventdata,
                                          mxArray * handles) {
    mexLocalFunctionTable save_local_function_table_
      = mclSetCurrentLocalFunctionTable(&_local_function_table_recarga_2_3);
    mclCopyArray(&hObject);
    mclCopyArray(&eventdata);
    mclCopyArray(&handles);
    mxDestroyArray(handles);
    mxDestroyArray(eventdata);
    mxDestroyArray(hObject);
    mclSetCurrentLocalFunctionTable(save_local_function_table_);
    /*
     * % hObject    handle to PptType (see GCBO)
     * % eventdata  reserved - to be defined in a future version of MATLAB
     * % handles    structure with handles and user data (see GUIDATA)
     * 
     * % Hints: contents = get(hObject,'String') returns PptType contents as cell array
     * %        contents{get(hObject,'Value')} returns selected item from PptType
     * 
     * 
     * % --- Executes during object creation, after setting all properties.
     */
}

/*
 * The function "Mrecarga_2_3_PptDepth_CreateFcn" is the implementation version
 * of the "recarga_2_3/PptDepth_CreateFcn" M-function from file
 * "u:\final_recarga6\recarga\recarga_2_3.m" (lines 1820-1835). It contains the
 * actual compiled code for that M-function. It is a static function and must
 * only be called from one of the interface functions, appearing below.
 */
/*
 * function PptDepth_CreateFcn(hObject, eventdata, handles)
 */
static void Mrecarga_2_3_PptDepth_CreateFcn(mxArray * hObject,
                                            mxArray * eventdata,
                                            mxArray * handles) {
    mexLocalFunctionTable save_local_function_table_
      = mclSetCurrentLocalFunctionTable(&_local_function_table_recarga_2_3);
    mxArray * ans = NULL;
    mclCopyArray(&hObject);
    mclCopyArray(&eventdata);
    mclCopyArray(&handles);
    /*
     * % hObject    handle to PptDepth (see GCBO)
     * % eventdata  reserved - to be defined in a future version of MATLAB
     * % handles    empty - handles not created until after all CreateFcns called
     * 
     * % Hint: edit controls usually have a white background on Windows.
     * %       See ISPC and COMPUTER.
     * if ispc
     */
    if (mlfTobool(mlfIspc())) {
        /*
         * set(hObject,'BackgroundColor','white');
         */
        mclAssignAns(
          &ans,
          mlfNSet(
            0, mclVa(hObject, "hObject"), _mxarray28_, _mxarray30_, NULL));
    /*
     * else
     */
    } else {
        /*
         * set(hObject,'BackgroundColor',get(0,'defaultUicontrolBackgroundColor'));
         */
        mclAssignAns(
          &ans,
          mlfNSet(
            0,
            mclVa(hObject, "hObject"),
            _mxarray28_,
            mlfNGet(1, _mxarray32_, _mxarray33_, NULL),
            NULL));
    /*
     * end
     */
    }
    mxDestroyArray(ans);
    mxDestroyArray(handles);
    mxDestroyArray(eventdata);
    mxDestroyArray(hObject);
    mclSetCurrentLocalFunctionTable(save_local_function_table_);
    /*
     * 
     * 
     * 
     */
}

/*
 * The function "Mrecarga_2_3_PptDepth_Callback" is the implementation version
 * of the "recarga_2_3/PptDepth_Callback" M-function from file
 * "u:\final_recarga6\recarga\recarga_2_3.m" (lines 1835-1848). It contains the
 * actual compiled code for that M-function. It is a static function and must
 * only be called from one of the interface functions, appearing below.
 */
/*
 * function PptDepth_Callback(hObject, eventdata, handles)
 */
static void Mrecarga_2_3_PptDepth_Callback(mxArray * hObject,
                                           mxArray * eventdata,
                                           mxArray * handles) {
    mexLocalFunctionTable save_local_function_table_
      = mclSetCurrentLocalFunctionTable(&_local_function_table_recarga_2_3);
    mclCopyArray(&hObject);
    mclCopyArray(&eventdata);
    mclCopyArray(&handles);
    mxDestroyArray(handles);
    mxDestroyArray(eventdata);
    mxDestroyArray(hObject);
    mclSetCurrentLocalFunctionTable(save_local_function_table_);
    /*
     * % hObject    handle to PptDepth (see GCBO)
     * % eventdata  reserved - to be defined in a future version of MATLAB
     * % handles    structure with handles and user data (see GUIDATA)
     * 
     * % Hints: get(hObject,'String') returns contents of PptDepth as text
     * %        str2double(get(hObject,'String')) returns contents of PptDepth as a double
     * 
     * 
     * 
     * 
     * 
     * % --- Executes during object creation, after setting all properties.
     */
}

/*
 * The function "Mrecarga_2_3_Units_CreateFcn" is the implementation version of
 * the "recarga_2_3/Units_CreateFcn" M-function from file
 * "u:\final_recarga6\recarga\recarga_2_3.m" (lines 1848-1863). It contains the
 * actual compiled code for that M-function. It is a static function and must
 * only be called from one of the interface functions, appearing below.
 */
/*
 * function Units_CreateFcn(hObject, eventdata, handles)
 */
static void Mrecarga_2_3_Units_CreateFcn(mxArray * hObject,
                                         mxArray * eventdata,
                                         mxArray * handles) {
    mexLocalFunctionTable save_local_function_table_
      = mclSetCurrentLocalFunctionTable(&_local_function_table_recarga_2_3);
    mxArray * prevunit = NULL;
    mxArray * ans = NULL;
    mclCopyArray(&hObject);
    mclCopyArray(&eventdata);
    mclCopyArray(&handles);
    /*
     * % hObject    handle to Units (see GCBO)
     * % eventdata  reserved - to be defined in a future version of MATLAB
     * % handles    empty - handles not created until after all CreateFcns called
     * 
     * % Hint: popupmenu controls usually have a white background on Windows.
     * %       See ISPC and COMPUTER.
     * if ispc
     */
    if (mlfTobool(mlfIspc())) {
        /*
         * set(hObject,'BackgroundColor','white');
         */
        mclAssignAns(
          &ans,
          mlfNSet(
            0, mclVa(hObject, "hObject"), _mxarray28_, _mxarray30_, NULL));
    /*
     * else
     */
    } else {
        /*
         * set(hObject,'BackgroundColor',get(0,'defaultUicontrolBackgroundColor'));
         */
        mclAssignAns(
          &ans,
          mlfNSet(
            0,
            mclVa(hObject, "hObject"),
            _mxarray28_,
            mlfNGet(1, _mxarray32_, _mxarray33_, NULL),
            NULL));
    /*
     * end
     */
    }
    /*
     * prevunit=1;
     */
    mlfAssign(&prevunit, _mxarray0_);
    mxDestroyArray(ans);
    mxDestroyArray(prevunit);
    mxDestroyArray(handles);
    mxDestroyArray(eventdata);
    mxDestroyArray(hObject);
    mclSetCurrentLocalFunctionTable(save_local_function_table_);
    /*
     * 
     * % --- Executes on selection change in Units.
     */
}

/*
 * The function "Mrecarga_2_3_Units_Callback" is the implementation version of
 * the "recarga_2_3/Units_Callback" M-function from file
 * "u:\final_recarga6\recarga\recarga_2_3.m" (lines 1863-1940). It contains the
 * actual compiled code for that M-function. It is a static function and must
 * only be called from one of the interface functions, appearing below.
 */
/*
 * function Units_Callback(hObject, eventdata, handles)
 */
static void Mrecarga_2_3_Units_Callback(mxArray * hObject,
                                        mxArray * eventdata,
                                        mxArray * handles) {
    mexLocalFunctionTable save_local_function_table_
      = mclSetCurrentLocalFunctionTable(&_local_function_table_recarga_2_3);
    mxArray * ans = NULL;
    mxArray * unit = NULL;
    mxArray * prevunit = NULL;
    mxArray * B4 = NULL;
    mxArray * B3 = NULL;
    mxArray * B2 = NULL;
    mxArray * B1 = NULL;
    mxArray * C4 = NULL;
    mxArray * C3 = NULL;
    mxArray * C2 = NULL;
    mxArray * C1 = NULL;
    mclCopyArray(&hObject);
    mclCopyArray(&eventdata);
    mclCopyArray(&handles);
    /*
     * % hObject    handle to Units (see GCBO)
     * % eventdata  reserved - to be defined in a future version of MATLAB
     * % handles    structure with handles and user data (see GUIDATA)
     * 
     * % Hints: contents = get(hObject,'String') returns Units contents as cell array
     * %        contents{get(hObject,'Value')} returns selected item from Units
     * C1 = 10.763910416709722573556258223628;  %m2 to ft2
     */
    mlfAssign(&C1, _mxarray91_);
    /*
     * C2 = 10.763910416709722573556258223628/43560;  %m2 to acre
     */
    mlfAssign(&C2, _mxarray92_);
    /*
     * C3 = 1/2.54;  %cm to in.
     */
    mlfAssign(&C3, _mxarray93_);
    /*
     * C4 = .0008107131937899125401845273267677; %m3 to acre-ft
     */
    mlfAssign(&C4, _mxarray94_);
    /*
     * %
     * B1 = 1/10.763910416709722573556258223628; %ft2 to m2
     */
    mlfAssign(&B1, _mxarray95_);
    /*
     * B2 = 4046.856422399999900285457752064;  %acre to m2
     */
    mlfAssign(&B2, _mxarray96_);
    /*
     * B3 = 2.54;  %in to cm
     */
    mlfAssign(&B3, _mxarray85_);
    /*
     * B4 = 1233.4818375475199544104; %acre-ft to m3
     */
    mlfAssign(&B4, _mxarray97_);
    /*
     * 
     * prevunit= get(handles.CurrentUnit,'Value');
     */
    mlfAssign(
      &prevunit,
      mlfNGet(
        1,
        mlfIndexRef(mclVa(handles, "handles"), ".CurrentUnit"),
        _mxarray44_,
        NULL));
    /*
     * unit = get(handles.Units,'Value');
     */
    mlfAssign(
      &unit,
      mlfNGet(
        1,
        mlfIndexRef(mclVa(handles, "handles"), ".Units"), _mxarray44_, NULL));
    /*
     * if unit == prevunit
     */
    if (mclEqBool(mclVv(unit, "unit"), mclVv(prevunit, "prevunit"))) {
    /*
     * else
     */
    } else {
        /*
         * if unit ==2 %convert Metric to English
         */
        if (mclEqBool(mclVv(unit, "unit"), _mxarray42_)) {
            /*
             * set(handles.Kroot,'String',num2str(str2num(get(handles.Kroot,'string'))*C3));
             */
            mclAssignAns(
              &ans,
              mlfNSet(
                0,
                mlfIndexRef(mclVa(handles, "handles"), ".Kroot"),
                _mxarray35_,
                mlfNum2str(
                  mclMtimes(
                    mlfStr2num(
                      NULL,
                      mlfNGet(
                        1,
                        mlfIndexRef(mclVa(handles, "handles"), ".Kroot"),
                        _mxarray98_,
                        NULL)),
                    mclVv(C3, "C3")),
                  NULL),
                NULL));
            /*
             * set(handles.Kstore,'String',num2str(str2num(get(handles.Kstore,'string'))*C3));
             */
            mclAssignAns(
              &ans,
              mlfNSet(
                0,
                mlfIndexRef(mclVa(handles, "handles"), ".Kstore"),
                _mxarray35_,
                mlfNum2str(
                  mclMtimes(
                    mlfStr2num(
                      NULL,
                      mlfNGet(
                        1,
                        mlfIndexRef(mclVa(handles, "handles"), ".Kstore"),
                        _mxarray98_,
                        NULL)),
                    mclVv(C3, "C3")),
                  NULL),
                NULL));
            /*
             * set(handles.Ksat,'String',num2str(str2num(get(handles.Ksat,'string'))*C3));
             */
            mclAssignAns(
              &ans,
              mlfNSet(
                0,
                mlfIndexRef(mclVa(handles, "handles"), ".Ksat"),
                _mxarray35_,
                mlfNum2str(
                  mclMtimes(
                    mlfStr2num(
                      NULL,
                      mlfNGet(
                        1,
                        mlfIndexRef(mclVa(handles, "handles"), ".Ksat"),
                        _mxarray98_,
                        NULL)),
                    mclVv(C3, "C3")),
                  NULL),
                NULL));
            /*
             * set(handles.Sd,'String',num2str(str2num(get(handles.Sd,'string'))*C3));
             */
            mclAssignAns(
              &ans,
              mlfNSet(
                0,
                mlfIndexRef(mclVa(handles, "handles"), ".Sd"),
                _mxarray35_,
                mlfNum2str(
                  mclMtimes(
                    mlfStr2num(
                      NULL,
                      mlfNGet(
                        1,
                        mlfIndexRef(mclVa(handles, "handles"), ".Sd"),
                        _mxarray98_,
                        NULL)),
                    mclVv(C3, "C3")),
                  NULL),
                NULL));
            /*
             * set(handles.Srz,'String',num2str(str2num(get(handles.Srz,'string'))*C3));
             */
            mclAssignAns(
              &ans,
              mlfNSet(
                0,
                mlfIndexRef(mclVa(handles, "handles"), ".Srz"),
                _mxarray35_,
                mlfNum2str(
                  mclMtimes(
                    mlfStr2num(
                      NULL,
                      mlfNGet(
                        1,
                        mlfIndexRef(mclVa(handles, "handles"), ".Srz"),
                        _mxarray98_,
                        NULL)),
                    mclVv(C3, "C3")),
                  NULL),
                NULL));
            /*
             * set(handles.St,'String',num2str(str2num(get(handles.St,'string'))*C3));
             */
            mclAssignAns(
              &ans,
              mlfNSet(
                0,
                mlfIndexRef(mclVa(handles, "handles"), ".St"),
                _mxarray35_,
                mlfNum2str(
                  mclMtimes(
                    mlfStr2num(
                      NULL,
                      mlfNGet(
                        1,
                        mlfIndexRef(mclVa(handles, "handles"), ".St"),
                        _mxarray98_,
                        NULL)),
                    mclVv(C3, "C3")),
                  NULL),
                NULL));
            /*
             * set(handles.UFlow,'String',num2str(str2num(get(handles.UFlow,'string'))*C3));
             */
            mclAssignAns(
              &ans,
              mlfNSet(
                0,
                mlfIndexRef(mclVa(handles, "handles"), ".UFlow"),
                _mxarray35_,
                mlfNum2str(
                  mclMtimes(
                    mlfStr2num(
                      NULL,
                      mlfNGet(
                        1,
                        mlfIndexRef(mclVa(handles, "handles"), ".UFlow"),
                        _mxarray98_,
                        NULL)),
                    mclVv(C3, "C3")),
                  NULL),
                NULL));
            /*
             * set(handles.Udiam,'String',num2str(str2num(get(handles.Udiam,'string'))*C3/10));
             */
            mclAssignAns(
              &ans,
              mlfNSet(
                0,
                mlfIndexRef(mclVa(handles, "handles"), ".Udiam"),
                _mxarray35_,
                mlfNum2str(
                  mclMrdivide(
                    mclMtimes(
                      mlfStr2num(
                        NULL,
                        mlfNGet(
                          1,
                          mlfIndexRef(mclVa(handles, "handles"), ".Udiam"),
                          _mxarray98_,
                          NULL)),
                      mclVv(C3, "C3")),
                    _mxarray70_),
                  NULL),
                NULL));
            /*
             * set(handles.AveET,'String',num2str(str2num(get(handles.AveET,'string'))*C3));
             */
            mclAssignAns(
              &ans,
              mlfNSet(
                0,
                mlfIndexRef(mclVa(handles, "handles"), ".AveET"),
                _mxarray35_,
                mlfNum2str(
                  mclMtimes(
                    mlfStr2num(
                      NULL,
                      mlfNGet(
                        1,
                        mlfIndexRef(mclVa(handles, "handles"), ".AveET"),
                        _mxarray98_,
                        NULL)),
                    mclVv(C3, "C3")),
                  NULL),
                NULL));
            /*
             * set(handles.PptDepth,'String',num2str(str2num(get(handles.PptDepth,'string'))*C3));
             */
            mclAssignAns(
              &ans,
              mlfNSet(
                0,
                mlfIndexRef(mclVa(handles, "handles"), ".PptDepth"),
                _mxarray35_,
                mlfNum2str(
                  mclMtimes(
                    mlfStr2num(
                      NULL,
                      mlfNGet(
                        1,
                        mlfIndexRef(mclVa(handles, "handles"), ".PptDepth"),
                        _mxarray98_,
                        NULL)),
                    mclVv(C3, "C3")),
                  NULL),
                NULL));
            /*
             * set(handles.BasinArea,'String',num2str(str2num(get(handles.BasinArea,'string'))*C2));
             */
            mclAssignAns(
              &ans,
              mlfNSet(
                0,
                mlfIndexRef(mclVa(handles, "handles"), ".BasinArea"),
                _mxarray35_,
                mlfNum2str(
                  mclMtimes(
                    mlfStr2num(
                      NULL,
                      mlfNGet(
                        1,
                        mlfIndexRef(mclVa(handles, "handles"), ".BasinArea"),
                        _mxarray98_,
                        NULL)),
                    mclVv(C2, "C2")),
                  NULL),
                NULL));
            /*
             * set(handles.RGArea,'String',num2str(str2num(get(handles.RGArea,'string'))*C1));
             */
            mclAssignAns(
              &ans,
              mlfNSet(
                0,
                mlfIndexRef(mclVa(handles, "handles"), ".RGArea"),
                _mxarray35_,
                mlfNum2str(
                  mclMtimes(
                    mlfStr2num(
                      NULL,
                      mlfNGet(
                        1,
                        mlfIndexRef(mclVa(handles, "handles"), ".RGArea"),
                        _mxarray98_,
                        NULL)),
                    mclVv(C1, "C1")),
                  NULL),
                NULL));
            /*
             * set(handles.Afunit1,'Visible','off');set(handles.Afunit2,'Visible','on');  
             */
            mclAssignAns(
              &ans,
              mlfNSet(
                0,
                mlfIndexRef(mclVa(handles, "handles"), ".Afunit1"),
                _mxarray22_,
                _mxarray24_,
                NULL));
            mclAssignAns(
              &ans,
              mlfNSet(
                0,
                mlfIndexRef(mclVa(handles, "handles"), ".Afunit2"),
                _mxarray22_,
                _mxarray89_,
                NULL));
            /*
             * set(handles.UDunit1,'Visible','off');set(handles.UDunit2,'Visible','on');  
             */
            mclAssignAns(
              &ans,
              mlfNSet(
                0,
                mlfIndexRef(mclVa(handles, "handles"), ".UDunit1"),
                _mxarray22_,
                _mxarray24_,
                NULL));
            mclAssignAns(
              &ans,
              mlfNSet(
                0,
                mlfIndexRef(mclVa(handles, "handles"), ".UDunit2"),
                _mxarray22_,
                _mxarray89_,
                NULL));
            /*
             * set(handles.Dpthunit1,'Visible','off');set(handles.Dpthunit2,'Visible','on');  
             */
            mclAssignAns(
              &ans,
              mlfNSet(
                0,
                mlfIndexRef(mclVa(handles, "handles"), ".Dpthunit1"),
                _mxarray22_,
                _mxarray24_,
                NULL));
            mclAssignAns(
              &ans,
              mlfNSet(
                0,
                mlfIndexRef(mclVa(handles, "handles"), ".Dpthunit2"),
                _mxarray22_,
                _mxarray89_,
                NULL));
            /*
             * set(handles.Atunit1,'Visible','off');set(handles.Atunit2,'Visible','on');  
             */
            mclAssignAns(
              &ans,
              mlfNSet(
                0,
                mlfIndexRef(mclVa(handles, "handles"), ".Atunit1"),
                _mxarray22_,
                _mxarray24_,
                NULL));
            mclAssignAns(
              &ans,
              mlfNSet(
                0,
                mlfIndexRef(mclVa(handles, "handles"), ".Atunit2"),
                _mxarray22_,
                _mxarray89_,
                NULL));
            /*
             * set(handles.Kunit1,'Visible','off');set(handles.Kunit2,'Visible','on');  
             */
            mclAssignAns(
              &ans,
              mlfNSet(
                0,
                mlfIndexRef(mclVa(handles, "handles"), ".Kunit1"),
                _mxarray22_,
                _mxarray24_,
                NULL));
            mclAssignAns(
              &ans,
              mlfNSet(
                0,
                mlfIndexRef(mclVa(handles, "handles"), ".Kunit2"),
                _mxarray22_,
                _mxarray89_,
                NULL));
            /*
             * set(handles.ETunit1,'Visible','off');set(handles.ETunit2,'Visible','on');  
             */
            mclAssignAns(
              &ans,
              mlfNSet(
                0,
                mlfIndexRef(mclVa(handles, "handles"), ".ETunit1"),
                _mxarray22_,
                _mxarray24_,
                NULL));
            mclAssignAns(
              &ans,
              mlfNSet(
                0,
                mlfIndexRef(mclVa(handles, "handles"), ".ETunit2"),
                _mxarray22_,
                _mxarray89_,
                NULL));
            /*
             * set(handles.Pptunit1,'Visible','off');set(handles.Pptunit2,'Visible','on');  
             */
            mclAssignAns(
              &ans,
              mlfNSet(
                0,
                mlfIndexRef(mclVa(handles, "handles"), ".Pptunit1"),
                _mxarray22_,
                _mxarray24_,
                NULL));
            mclAssignAns(
              &ans,
              mlfNSet(
                0,
                mlfIndexRef(mclVa(handles, "handles"), ".Pptunit2"),
                _mxarray22_,
                _mxarray89_,
                NULL));
            /*
             * set(handles.Tribunit1,'Visible','off');set(handles.Tribunit2,'Visible','on');  
             */
            mclAssignAns(
              &ans,
              mlfNSet(
                0,
                mlfIndexRef(mclVa(handles, "handles"), ".Tribunit1"),
                _mxarray22_,
                _mxarray24_,
                NULL));
            mclAssignAns(
              &ans,
              mlfNSet(
                0,
                mlfIndexRef(mclVa(handles, "handles"), ".Tribunit2"),
                _mxarray22_,
                _mxarray89_,
                NULL));
            /*
             * set(handles.Outunit1,'Visible','off');set(handles.Outunit2,'Visible','on');  
             */
            mclAssignAns(
              &ans,
              mlfNSet(
                0,
                mlfIndexRef(mclVa(handles, "handles"), ".Outunit1"),
                _mxarray22_,
                _mxarray24_,
                NULL));
            mclAssignAns(
              &ans,
              mlfNSet(
                0,
                mlfIndexRef(mclVa(handles, "handles"), ".Outunit2"),
                _mxarray22_,
                _mxarray89_,
                NULL));
            /*
             * set(handles.Usi,'Visible','off');set(handles.Uus,'Visible','on');  
             */
            mclAssignAns(
              &ans,
              mlfNSet(
                0,
                mlfIndexRef(mclVa(handles, "handles"), ".Usi"),
                _mxarray22_,
                _mxarray24_,
                NULL));
            mclAssignAns(
              &ans,
              mlfNSet(
                0,
                mlfIndexRef(mclVa(handles, "handles"), ".Uus"),
                _mxarray22_,
                _mxarray89_,
                NULL));
            /*
             * set(handles.text115,'Visible','off');set(handles.text114,'Visible','on');  
             */
            mclAssignAns(
              &ans,
              mlfNSet(
                0,
                mlfIndexRef(mclVa(handles, "handles"), ".text115"),
                _mxarray22_,
                _mxarray24_,
                NULL));
            mclAssignAns(
              &ans,
              mlfNSet(
                0,
                mlfIndexRef(mclVa(handles, "handles"), ".text114"),
                _mxarray22_,
                _mxarray89_,
                NULL));
            /*
             * set(handles.text116,'Visible','off');set(handles.text110,'Visible','on'); 
             */
            mclAssignAns(
              &ans,
              mlfNSet(
                0,
                mlfIndexRef(mclVa(handles, "handles"), ".text116"),
                _mxarray22_,
                _mxarray24_,
                NULL));
            mclAssignAns(
              &ans,
              mlfNSet(
                0,
                mlfIndexRef(mclVa(handles, "handles"), ".text110"),
                _mxarray22_,
                _mxarray89_,
                NULL));
        /*
         * else %Convert English to Metric
         */
        } else {
            /*
             * set(handles.Kroot,'String',num2str(str2num(get(handles.Kroot,'string'))*B3));
             */
            mclAssignAns(
              &ans,
              mlfNSet(
                0,
                mlfIndexRef(mclVa(handles, "handles"), ".Kroot"),
                _mxarray35_,
                mlfNum2str(
                  mclMtimes(
                    mlfStr2num(
                      NULL,
                      mlfNGet(
                        1,
                        mlfIndexRef(mclVa(handles, "handles"), ".Kroot"),
                        _mxarray98_,
                        NULL)),
                    mclVv(B3, "B3")),
                  NULL),
                NULL));
            /*
             * set(handles.Kstore,'String',num2str(str2num(get(handles.Kstore,'string'))*B3));
             */
            mclAssignAns(
              &ans,
              mlfNSet(
                0,
                mlfIndexRef(mclVa(handles, "handles"), ".Kstore"),
                _mxarray35_,
                mlfNum2str(
                  mclMtimes(
                    mlfStr2num(
                      NULL,
                      mlfNGet(
                        1,
                        mlfIndexRef(mclVa(handles, "handles"), ".Kstore"),
                        _mxarray98_,
                        NULL)),
                    mclVv(B3, "B3")),
                  NULL),
                NULL));
            /*
             * set(handles.Ksat,'String',num2str(str2num(get(handles.Ksat,'string'))*B3));
             */
            mclAssignAns(
              &ans,
              mlfNSet(
                0,
                mlfIndexRef(mclVa(handles, "handles"), ".Ksat"),
                _mxarray35_,
                mlfNum2str(
                  mclMtimes(
                    mlfStr2num(
                      NULL,
                      mlfNGet(
                        1,
                        mlfIndexRef(mclVa(handles, "handles"), ".Ksat"),
                        _mxarray98_,
                        NULL)),
                    mclVv(B3, "B3")),
                  NULL),
                NULL));
            /*
             * set(handles.Sd,'String',num2str(str2num(get(handles.Sd,'string'))*B3));
             */
            mclAssignAns(
              &ans,
              mlfNSet(
                0,
                mlfIndexRef(mclVa(handles, "handles"), ".Sd"),
                _mxarray35_,
                mlfNum2str(
                  mclMtimes(
                    mlfStr2num(
                      NULL,
                      mlfNGet(
                        1,
                        mlfIndexRef(mclVa(handles, "handles"), ".Sd"),
                        _mxarray98_,
                        NULL)),
                    mclVv(B3, "B3")),
                  NULL),
                NULL));
            /*
             * set(handles.Srz,'String',num2str(str2num(get(handles.Srz,'string'))*B3));
             */
            mclAssignAns(
              &ans,
              mlfNSet(
                0,
                mlfIndexRef(mclVa(handles, "handles"), ".Srz"),
                _mxarray35_,
                mlfNum2str(
                  mclMtimes(
                    mlfStr2num(
                      NULL,
                      mlfNGet(
                        1,
                        mlfIndexRef(mclVa(handles, "handles"), ".Srz"),
                        _mxarray98_,
                        NULL)),
                    mclVv(B3, "B3")),
                  NULL),
                NULL));
            /*
             * set(handles.St,'String',num2str(str2num(get(handles.St,'string'))*B3));
             */
            mclAssignAns(
              &ans,
              mlfNSet(
                0,
                mlfIndexRef(mclVa(handles, "handles"), ".St"),
                _mxarray35_,
                mlfNum2str(
                  mclMtimes(
                    mlfStr2num(
                      NULL,
                      mlfNGet(
                        1,
                        mlfIndexRef(mclVa(handles, "handles"), ".St"),
                        _mxarray98_,
                        NULL)),
                    mclVv(B3, "B3")),
                  NULL),
                NULL));
            /*
             * set(handles.UFlow,'String',num2str(str2num(get(handles.UFlow,'string'))*B3));
             */
            mclAssignAns(
              &ans,
              mlfNSet(
                0,
                mlfIndexRef(mclVa(handles, "handles"), ".UFlow"),
                _mxarray35_,
                mlfNum2str(
                  mclMtimes(
                    mlfStr2num(
                      NULL,
                      mlfNGet(
                        1,
                        mlfIndexRef(mclVa(handles, "handles"), ".UFlow"),
                        _mxarray98_,
                        NULL)),
                    mclVv(B3, "B3")),
                  NULL),
                NULL));
            /*
             * set(handles.Udiam,'String',num2str(str2num(get(handles.Udiam,'string'))*B3*10));
             */
            mclAssignAns(
              &ans,
              mlfNSet(
                0,
                mlfIndexRef(mclVa(handles, "handles"), ".Udiam"),
                _mxarray35_,
                mlfNum2str(
                  mclMtimes(
                    mclMtimes(
                      mlfStr2num(
                        NULL,
                        mlfNGet(
                          1,
                          mlfIndexRef(mclVa(handles, "handles"), ".Udiam"),
                          _mxarray98_,
                          NULL)),
                      mclVv(B3, "B3")),
                    _mxarray70_),
                  NULL),
                NULL));
            /*
             * set(handles.AveET,'String',num2str(str2num(get(handles.AveET,'string'))*B3));
             */
            mclAssignAns(
              &ans,
              mlfNSet(
                0,
                mlfIndexRef(mclVa(handles, "handles"), ".AveET"),
                _mxarray35_,
                mlfNum2str(
                  mclMtimes(
                    mlfStr2num(
                      NULL,
                      mlfNGet(
                        1,
                        mlfIndexRef(mclVa(handles, "handles"), ".AveET"),
                        _mxarray98_,
                        NULL)),
                    mclVv(B3, "B3")),
                  NULL),
                NULL));
            /*
             * set(handles.PptDepth,'String',num2str(str2num(get(handles.PptDepth,'string'))*B3));
             */
            mclAssignAns(
              &ans,
              mlfNSet(
                0,
                mlfIndexRef(mclVa(handles, "handles"), ".PptDepth"),
                _mxarray35_,
                mlfNum2str(
                  mclMtimes(
                    mlfStr2num(
                      NULL,
                      mlfNGet(
                        1,
                        mlfIndexRef(mclVa(handles, "handles"), ".PptDepth"),
                        _mxarray98_,
                        NULL)),
                    mclVv(B3, "B3")),
                  NULL),
                NULL));
            /*
             * set(handles.BasinArea,'String',num2str(str2num(get(handles.BasinArea,'string'))*B2));
             */
            mclAssignAns(
              &ans,
              mlfNSet(
                0,
                mlfIndexRef(mclVa(handles, "handles"), ".BasinArea"),
                _mxarray35_,
                mlfNum2str(
                  mclMtimes(
                    mlfStr2num(
                      NULL,
                      mlfNGet(
                        1,
                        mlfIndexRef(mclVa(handles, "handles"), ".BasinArea"),
                        _mxarray98_,
                        NULL)),
                    mclVv(B2, "B2")),
                  NULL),
                NULL));
            /*
             * set(handles.RGArea,'String',num2str(str2num(get(handles.RGArea,'string'))*B1));
             */
            mclAssignAns(
              &ans,
              mlfNSet(
                0,
                mlfIndexRef(mclVa(handles, "handles"), ".RGArea"),
                _mxarray35_,
                mlfNum2str(
                  mclMtimes(
                    mlfStr2num(
                      NULL,
                      mlfNGet(
                        1,
                        mlfIndexRef(mclVa(handles, "handles"), ".RGArea"),
                        _mxarray98_,
                        NULL)),
                    mclVv(B1, "B1")),
                  NULL),
                NULL));
            /*
             * set(handles.Afunit2,'Visible','off');set(handles.Afunit1,'Visible','on');  
             */
            mclAssignAns(
              &ans,
              mlfNSet(
                0,
                mlfIndexRef(mclVa(handles, "handles"), ".Afunit2"),
                _mxarray22_,
                _mxarray24_,
                NULL));
            mclAssignAns(
              &ans,
              mlfNSet(
                0,
                mlfIndexRef(mclVa(handles, "handles"), ".Afunit1"),
                _mxarray22_,
                _mxarray89_,
                NULL));
            /*
             * set(handles.UDunit2,'Visible','off');set(handles.UDunit1,'Visible','on');  
             */
            mclAssignAns(
              &ans,
              mlfNSet(
                0,
                mlfIndexRef(mclVa(handles, "handles"), ".UDunit2"),
                _mxarray22_,
                _mxarray24_,
                NULL));
            mclAssignAns(
              &ans,
              mlfNSet(
                0,
                mlfIndexRef(mclVa(handles, "handles"), ".UDunit1"),
                _mxarray22_,
                _mxarray89_,
                NULL));
            /*
             * set(handles.Dpthunit2,'Visible','off');set(handles.Dpthunit1,'Visible','on'); 
             */
            mclAssignAns(
              &ans,
              mlfNSet(
                0,
                mlfIndexRef(mclVa(handles, "handles"), ".Dpthunit2"),
                _mxarray22_,
                _mxarray24_,
                NULL));
            mclAssignAns(
              &ans,
              mlfNSet(
                0,
                mlfIndexRef(mclVa(handles, "handles"), ".Dpthunit1"),
                _mxarray22_,
                _mxarray89_,
                NULL));
            /*
             * set(handles.Atunit2,'Visible','off');set(handles.Atunit1,'Visible','on');  
             */
            mclAssignAns(
              &ans,
              mlfNSet(
                0,
                mlfIndexRef(mclVa(handles, "handles"), ".Atunit2"),
                _mxarray22_,
                _mxarray24_,
                NULL));
            mclAssignAns(
              &ans,
              mlfNSet(
                0,
                mlfIndexRef(mclVa(handles, "handles"), ".Atunit1"),
                _mxarray22_,
                _mxarray89_,
                NULL));
            /*
             * set(handles.Kunit2,'Visible','off');set(handles.Kunit1,'Visible','on');  
             */
            mclAssignAns(
              &ans,
              mlfNSet(
                0,
                mlfIndexRef(mclVa(handles, "handles"), ".Kunit2"),
                _mxarray22_,
                _mxarray24_,
                NULL));
            mclAssignAns(
              &ans,
              mlfNSet(
                0,
                mlfIndexRef(mclVa(handles, "handles"), ".Kunit1"),
                _mxarray22_,
                _mxarray89_,
                NULL));
            /*
             * set(handles.ETunit2,'Visible','off');set(handles.ETunit1,'Visible','on');  
             */
            mclAssignAns(
              &ans,
              mlfNSet(
                0,
                mlfIndexRef(mclVa(handles, "handles"), ".ETunit2"),
                _mxarray22_,
                _mxarray24_,
                NULL));
            mclAssignAns(
              &ans,
              mlfNSet(
                0,
                mlfIndexRef(mclVa(handles, "handles"), ".ETunit1"),
                _mxarray22_,
                _mxarray89_,
                NULL));
            /*
             * set(handles.Pptunit2,'Visible','off');set(handles.Pptunit1,'Visible','on');  
             */
            mclAssignAns(
              &ans,
              mlfNSet(
                0,
                mlfIndexRef(mclVa(handles, "handles"), ".Pptunit2"),
                _mxarray22_,
                _mxarray24_,
                NULL));
            mclAssignAns(
              &ans,
              mlfNSet(
                0,
                mlfIndexRef(mclVa(handles, "handles"), ".Pptunit1"),
                _mxarray22_,
                _mxarray89_,
                NULL));
            /*
             * set(handles.Tribunit2,'Visible','off');set(handles.Tribunit1,'Visible','on');  
             */
            mclAssignAns(
              &ans,
              mlfNSet(
                0,
                mlfIndexRef(mclVa(handles, "handles"), ".Tribunit2"),
                _mxarray22_,
                _mxarray24_,
                NULL));
            mclAssignAns(
              &ans,
              mlfNSet(
                0,
                mlfIndexRef(mclVa(handles, "handles"), ".Tribunit1"),
                _mxarray22_,
                _mxarray89_,
                NULL));
            /*
             * set(handles.Outunit2,'Visible','off');set(handles.Outunit1,'Visible','on');  
             */
            mclAssignAns(
              &ans,
              mlfNSet(
                0,
                mlfIndexRef(mclVa(handles, "handles"), ".Outunit2"),
                _mxarray22_,
                _mxarray24_,
                NULL));
            mclAssignAns(
              &ans,
              mlfNSet(
                0,
                mlfIndexRef(mclVa(handles, "handles"), ".Outunit1"),
                _mxarray22_,
                _mxarray89_,
                NULL));
            /*
             * set(handles.Uus,'Visible','off');set(handles.Usi,'Visible','on');  
             */
            mclAssignAns(
              &ans,
              mlfNSet(
                0,
                mlfIndexRef(mclVa(handles, "handles"), ".Uus"),
                _mxarray22_,
                _mxarray24_,
                NULL));
            mclAssignAns(
              &ans,
              mlfNSet(
                0,
                mlfIndexRef(mclVa(handles, "handles"), ".Usi"),
                _mxarray22_,
                _mxarray89_,
                NULL));
            /*
             * set(handles.text114,'Visible','off');set(handles.text115,'Visible','on'); 
             */
            mclAssignAns(
              &ans,
              mlfNSet(
                0,
                mlfIndexRef(mclVa(handles, "handles"), ".text114"),
                _mxarray22_,
                _mxarray24_,
                NULL));
            mclAssignAns(
              &ans,
              mlfNSet(
                0,
                mlfIndexRef(mclVa(handles, "handles"), ".text115"),
                _mxarray22_,
                _mxarray89_,
                NULL));
            /*
             * set(handles.text110,'Visible','off');set(handles.text116,'Visible','on'); 
             */
            mclAssignAns(
              &ans,
              mlfNSet(
                0,
                mlfIndexRef(mclVa(handles, "handles"), ".text110"),
                _mxarray22_,
                _mxarray24_,
                NULL));
            mclAssignAns(
              &ans,
              mlfNSet(
                0,
                mlfIndexRef(mclVa(handles, "handles"), ".text116"),
                _mxarray22_,
                _mxarray89_,
                NULL));
        /*
         * end
         */
        }
    /*
     * end
     */
    }
    /*
     * set(handles.CurrentUnit,'Value',unit);
     */
    mclAssignAns(
      &ans,
      mlfNSet(
        0,
        mlfIndexRef(mclVa(handles, "handles"), ".CurrentUnit"),
        _mxarray44_,
        mclVv(unit, "unit"),
        NULL));
    mxDestroyArray(C1);
    mxDestroyArray(C2);
    mxDestroyArray(C3);
    mxDestroyArray(C4);
    mxDestroyArray(B1);
    mxDestroyArray(B2);
    mxDestroyArray(B3);
    mxDestroyArray(B4);
    mxDestroyArray(prevunit);
    mxDestroyArray(unit);
    mxDestroyArray(ans);
    mxDestroyArray(handles);
    mxDestroyArray(eventdata);
    mxDestroyArray(hObject);
    mclSetCurrentLocalFunctionTable(save_local_function_table_);
    /*
     * 
     * 
     * % --- Executes during object creation, after setting all properties.
     */
}

/*
 * The function "Mrecarga_2_3_CurrentUnit_CreateFcn" is the implementation
 * version of the "recarga_2_3/CurrentUnit_CreateFcn" M-function from file
 * "u:\final_recarga6\recarga\recarga_2_3.m" (lines 1940-1955). It contains the
 * actual compiled code for that M-function. It is a static function and must
 * only be called from one of the interface functions, appearing below.
 */
/*
 * function CurrentUnit_CreateFcn(hObject, eventdata, handles)
 */
static void Mrecarga_2_3_CurrentUnit_CreateFcn(mxArray * hObject,
                                               mxArray * eventdata,
                                               mxArray * handles) {
    mexLocalFunctionTable save_local_function_table_
      = mclSetCurrentLocalFunctionTable(&_local_function_table_recarga_2_3);
    mxArray * ans = NULL;
    mclCopyArray(&hObject);
    mclCopyArray(&eventdata);
    mclCopyArray(&handles);
    /*
     * % hObject    handle to CurrentUnit (see GCBO)
     * % eventdata  reserved - to be defined in a future version of MATLAB
     * % handles    empty - handles not created until after all CreateFcns called
     * 
     * % Hint: popupmenu controls usually have a white background on Windows.
     * %       See ISPC and COMPUTER.
     * if ispc
     */
    if (mlfTobool(mlfIspc())) {
        /*
         * set(hObject,'BackgroundColor','white');
         */
        mclAssignAns(
          &ans,
          mlfNSet(
            0, mclVa(hObject, "hObject"), _mxarray28_, _mxarray30_, NULL));
    /*
     * else
     */
    } else {
        /*
         * set(hObject,'BackgroundColor',get(0,'defaultUicontrolBackgroundColor'));
         */
        mclAssignAns(
          &ans,
          mlfNSet(
            0,
            mclVa(hObject, "hObject"),
            _mxarray28_,
            mlfNGet(1, _mxarray32_, _mxarray33_, NULL),
            NULL));
    /*
     * end
     */
    }
    mxDestroyArray(ans);
    mxDestroyArray(handles);
    mxDestroyArray(eventdata);
    mxDestroyArray(hObject);
    mclSetCurrentLocalFunctionTable(save_local_function_table_);
    /*
     * 
     * 
     * % --- Executes on selection change in CurrentUnit.
     */
}

/*
 * The function "Mrecarga_2_3_CurrentUnit_Callback" is the implementation
 * version of the "recarga_2_3/CurrentUnit_Callback" M-function from file
 * "u:\final_recarga6\recarga\recarga_2_3.m" (lines 1955-1965). It contains the
 * actual compiled code for that M-function. It is a static function and must
 * only be called from one of the interface functions, appearing below.
 */
/*
 * function CurrentUnit_Callback(hObject, eventdata, handles)
 */
static void Mrecarga_2_3_CurrentUnit_Callback(mxArray * hObject,
                                              mxArray * eventdata,
                                              mxArray * handles) {
    mexLocalFunctionTable save_local_function_table_
      = mclSetCurrentLocalFunctionTable(&_local_function_table_recarga_2_3);
    mclCopyArray(&hObject);
    mclCopyArray(&eventdata);
    mclCopyArray(&handles);
    mxDestroyArray(handles);
    mxDestroyArray(eventdata);
    mxDestroyArray(hObject);
    mclSetCurrentLocalFunctionTable(save_local_function_table_);
    /*
     * % hObject    handle to CurrentUnit (see GCBO)
     * % eventdata  reserved - to be defined in a future version of MATLAB
     * % handles    structure with handles and user data (see GUIDATA)
     * 
     * % Hints: contents = get(hObject,'String') returns CurrentUnit contents as cell array
     * %        contents{get(hObject,'Value')} returns selected item from CurrentUnit
     * 
     * 
     * % --- Executes on button press in Far.
     */
}

/*
 * The function "Mrecarga_2_3_Far_Callback" is the implementation version of
 * the "recarga_2_3/Far_Callback" M-function from file
 * "u:\final_recarga6\recarga\recarga_2_3.m" (lines 1965-2196). It contains the
 * actual compiled code for that M-function. It is a static function and must
 * only be called from one of the interface functions, appearing below.
 */
/*
 * function Far_Callback(hObject, eventdata, handles)
 */
static void Mrecarga_2_3_Far_Callback(mxArray * hObject,
                                      mxArray * eventdata,
                                      mxArray * handles) {
    mexLocalFunctionTable save_local_function_table_
      = mclSetCurrentLocalFunctionTable(&_local_function_table_recarga_2_3);
    mxArray * lnfactors2 = NULL;
    mxArray * idx2 = NULL;
    mxArray * out = NULL;
    mxArray * in = NULL;
    mxArray * a = NULL;
    mxArray * b = NULL;
    mxArray * fit = NULL;
    mxArray * lnfactors = NULL;
    mxArray * idx = NULL;
    mxArray * ans = NULL;
    mxArray * Dstay = NULL;
    mxArray * inot = NULL;
    mxArray * tstponded = NULL;
    mxArray * maxpond = NULL;
    mxArray * Dstore = NULL;
    mxArray * Dudrain = NULL;
    mxArray * Drecharge = NULL;
    mxArray * Devap = NULL;
    mxArray * Drunoff = NULL;
    mxArray * Drunon = NULL;
    mxArray * Dperv = NULL;
    mxArray * Dimp = NULL;
    mxArray * Dprecip = NULL;
    mxArray * PptFile = NULL;
    mxArray * PptDepth = NULL;
    mxArray * PptName = NULL;
    mxArray * PptType = NULL;
    mxArray * nprecip = NULL;
    mxArray * infile = NULL;
    mxArray * filename = NULL;
    mxArray * fileext = NULL;
    mxArray * Record = NULL;
    mxArray * Summary = NULL;
    mxArray * outname = NULL;
    mxArray * stime = NULL;
    mxArray * dt = NULL;
    mxArray * time = NULL;
    mxArray * rundays = NULL;
    mxArray * HydroCalc = NULL;
    mxArray * Umax = NULL;
    mxArray * Urate = NULL;
    mxArray * Kst = NULL;
    mxArray * Krz = NULL;
    mxArray * Kcz = NULL;
    mxArray * Scz = NULL;
    mxArray * Srz = NULL;
    mxArray * St = NULL;
    mxArray * dmin = NULL;
    mxArray * RTexture = NULL;
    mxArray * STexture = NULL;
    mxArray * NTexture = NULL;
    mxArray * Ssoilnumber = NULL;
    mxArray * Rsoilnumber = NULL;
    mxArray * Nsoilnumber = NULL;
    mxArray * soilnames = NULL;
    mxArray * soilsdata = NULL;
    mxArray * avet = NULL;
    mxArray * Sd = NULL;
    mxArray * CN = NULL;
    mxArray * TribA = NULL;
    mxArray * EIA = NULL;
    mxArray * Arg = NULL;
    mxArray * f = NULL;
    mxArray * i = NULL;
    mxArray * new_factors = NULL;
    mxArray * factors = NULL;
    mxArray * k = NULL;
    mxArray * unit = NULL;
    mclCopyArray(&hObject);
    mclCopyArray(&eventdata);
    mclCopyArray(&handles);
    /*
     * % hObject    handle to Far (see GCBO)
     * % eventdata  reserved - to be defined in a future version of MATLAB
     * % handles    structure with handles and user data (see GUIDATA)
     * 
     * 
     * unit = get(handles.Units,'Value');
     */
    mlfAssign(
      &unit,
      mlfNGet(
        1,
        mlfIndexRef(mclVa(handles, "handles"), ".Units"), _mxarray44_, NULL));
    /*
     * 
     * for k = 1 : 2 
     */
    {
        int v_ = mclForIntStart(1);
        int e_ = 2;
        if (v_ > e_) {
            mlfAssign(&k, _mxarray11_);
        } else {
            /*
             * 
             * 
             * if k == 1
             * factors(1,:) = [0.01 0.05 .10 0.15 0.25];
             * else
             * factors(2,:) = new_factors;    
             * end
             * 
             * 
             * for i = 1:5
             * 
             * f = factors(k,i);
             * if unit ==2   
             * Arg = str2num(get(handles.BasinArea,'String'))*43560*f %Bioretention Cell Size 
             * else
             * Arg = str2num(get(handles.BasinArea,'String'))*f %Bioretention Cell Size 
             * end
             * 
             * EIA = str2num(get(handles.ImpA,'String'));  %Percent impervious area
             * TribA = str2num(get(handles.BasinArea,'String'));  %Total Tributary Area
             * CN = str2num(get(handles.CN,'String'));
             * %g=9.8;		% acceleration of gravity [m/s2]
             * Sd=.35;		% depression storage in pervious area [cm]
             * %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
             * % EVAPORATION PARAMETERS
             * %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
             * avet= str2num(get(handles.AveET,'String'));
             * %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
             * % SOIL SENSITIVITY PARAMETERS:
             * %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
             * if unit ==1
             * soilsdata=dlmread('soilsDNR.txt','\t',[0 1 10 4]);
             * else
             * soilsdata=dlmread('soilsUS.txt','\t',[0 1 10 4]);
             * end
             * soilnames=textread('soilslist.txt','%s','delimiter','\n','whitespace','');
             * Nsoilnumber = get(handles.NativeTexture,'Value');
             * Rsoilnumber = get(handles.RootTexture,'Value');
             * Ssoilnumber = get(handles.StorageTexture,'Value');
             * NTexture = soilnames(Nsoilnumber,1);
             * STexture = soilnames(Ssoilnumber,1);
             * RTexture = soilnames(Rsoilnumber,1);
             * dmin = str2num(get(handles.Sd,'String'));
             * St = str2num(get(handles.St,'String'));  %Storage Zone thickness
             * Srz = str2num(get(handles.Srz,'String'));  %Root Zone thickness
             * Scz = 10;  %Default value for Control Zone thickness
             * Kcz= str2num(get(handles.Ksat,'String'));  %Control Zone Sat. Hydraulic Conductivity
             * Krz = str2num(get(handles.Kroot,'String'));  %Root Zone Sat. Hydraulic Conductivity
             * Kst = str2num(get(handles.Kstore,'String')); %Storage Zone Sat. Hydraulic Conductivity
             * if St==0    %Allow for no storage by dividing control zone into two equal layers
             * St=5;  
             * Scz=5;
             * Kst = Kcz;
             * STexture = NTexture;
             * end
             * %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
             * %  UNDERDRAIN SIZING
             * %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
             * Urate = str2num(get(handles.UFlow,'String'));
             * Umax = (Urate/100)*(Arg/3600); %Max. Underdrain flow [m3/sec]
             * %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
             * % MODELING PARAMETERS
             * %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
             * % TEMPORAL:
             * HydroCalc = get(handles.SimType,'Value');  %1: Continuous, 2: Single Event, 3: User Type
             * if HydroCalc == 2
             * rundays = 3;
             * else rundays = str2num(get(handles.Length,'String'));
             * end
             * time=rundays*24*60;			% min in data file
             * dt=15;						% TIME STEP [min]
             * stime=time/60;				% total time of simulation [h]
             * dt=dt/60;					% TIME STEP [h]
             * %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
             * %DATAFILE RETRIEVAL
             * %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
             * outname = get(handles.Output,'String');
             * Summary = get(handles.Summary,'Value');
             * Record = get(handles.Record,'Value');
             * fileext = '.txt';
             * if HydroCalc == 1
             * filename = get(handles.Input,'String');
             * infile = strcat(filename,fileext);
             * nprecip=dlmread(infile,'\t',[1 0 ceil(stime)+1 2]);
             * if unit ==1 
             * nprecip(:,2)=nprecip(:,2)./10;      %convert Precip from [mm h-1] to [cm h-1]
             * nprecip(:,3)=nprecip(:,3)./10;      %convert Evap from [mm h-1] to [cm h-1]
             * else
             * end
             * elseif HydroCalc == 2
             * PptType = get(handles.PptType,'Value'); %1: Type I, 2: Type IA, 3: Type II, 4: Type III
             * if PptType == 1
             * PptName = 'TypeI';
             * elseif PptType ==2 
             * PptName = 'TypeIA'; 
             * elseif PptType == 3 
             * PptName = 'TypeII';
             * else 
             * PptName = 'TypeIII';
             * end
             * PptDepth = str2num(get(handles.PptDepth,'String'));
             * PptFile = num2str(strcat(PptName,'.txt'));
             * nprecip = dlmread(PptFile,'\t',[1 0 ceil(stime)+1 2]);
             * nprecip(:,2)=nprecip(:,2).*PptDepth;      %convert Precip from [mm h-1] to [cm h-1]
             * nprecip(:,3)=nprecip(:,3).*avet/24;      %convert Evap from [mm h-1] to [cm h-1]
             * else
             * Sd = 0;  
             * EIA = 100;
             * filename = get(handles.Input,'String');
             * infile = strcat(filename,fileext);
             * nprecip=dlmread(infile,'\t',[1 0 ceil(stime)+1 2]);
             * nprecip(:,2)=nprecip(:,2)./10;      %convert Precip from [mm h-1] to [cm h-1]
             * nprecip(:,3)=nprecip(:,3)./10;      %convert Evap from [mm h-1] to [cm h-1]
             * end
             * %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
             * %Run Modules
             * %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
             * if unit == 1
             * [Dprecip,Dimp,Dperv,Drunon,Drunoff,Devap,Drecharge,Dudrain,Dstore,maxpond,tstponded,inot] = recarga(nprecip,Sd,avet,rundays,outname,Summary,Record,dmin,Srz,St,Rsoilnumber,Ssoilnumber,Nsoilnumber,Krz,Kst,Kcz,Urate,CN,EIA,Arg,TribA);
             * else
             * nprecip(:,2)=nprecip(:,2).*2.54; nprecip(:,3)=nprecip(:,3).*2.54;
             * [Dprecip,Dimp,Dperv,Drunon,Drunoff,Devap,Drecharge,Dudrain,Dstore,maxpond,tstponded,inot] = recarga_us(nprecip,Sd,avet,rundays,outname,Summary,Record,dmin,Srz,St,Rsoilnumber,Ssoilnumber,Nsoilnumber,Krz,Kst,Kcz,Urate,CN,EIA,Arg,TribA);
             * end
             * Dstay(k,i) = Dprecip - Drunoff- Dudrain
             * 
             * if ispc
             * set(hObject,'BackgroundColor','white');
             * else
             * set(hObject,'BackgroundColor',get(0,'defaultUicontrolBackgroundColor'));
             * end
             * end
             * 
             * %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
             * %Fit Stayon and factor to an exponential curve
             * %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
             * if k == 1
             * if unit ==2
             * idx(k,:) = find(abs(Dstay(k,:)-Dprecip)>.0001);
             * 
             * lnfactors = log(factors(idx(k,:)));
             * fit = [Dstay(idx(k,:))' ones(size(idx(k,:),2),1)] \ lnfactors';
             * b(k) = fit(1)
             * a(k) = exp(fit(2))
             * 
             * 
             * in = str2num(get(handles.target_stayon,'String'));
             * out(k) = (a(k)*exp(b(k)*in))
             * if out(k)>.02
             * new_factors = [out(1) out(1)-0.02 out(1)+0.02 out(1)-0.01 out(1)+0.01];
             * else
             * new_factors = [out(1) out(1)+0.01 out(1)+0.02 out(1)+0.03 out(1)+0.04];
             * end
             * 
             * axes(handles.axes9)
             * plot(Dstay(k,:), (factors*100))
             * 
             * else
             * 
             * idx(k,:) = find(abs(Dstay(k,:)-Dprecip)>.0001);
             * 
             * lnfactors = log(factors(idx(k,:)));
             * fit = [((Dstay(idx(k,:)))/2.54)' ones(size(idx(k,:),2),1)] \ lnfactors';
             * b(k) = fit(1)
             * a(k) = exp(fit(2))
             * 
             * 
             * in = str2num(get(handles.target_stayon,'String'));
             * out(k) = (a(k)*exp(b(k)*(in/2.54)))
             * if out(k)>.02
             * new_factors = [out(1) out(1)-0.02 out(1)+0.02 out(1)-0.01 out(1)+0.01];
             * else
             * new_factors = [out(1) out(1)+0.01 out(1)+0.02 out(1)+0.03 out(1)+0.04];
             * end
             * new_factors = [out(1) out(1)-0.02 out(1)+0.02 out(1)-0.01 out(1)+0.01];
             * axes(handles.axes9)
             * plot(Dstay(k,:), (factors*100))
             * 
             * 
             * end
             * 
             * 
             * 
             * else
             * if unit ==2
             * idx2(k,:) = find((Dstay(2,:)));   
             * lnfactors2 = log(factors(2,:));
             * fit = [((Dstay(2,:)))' ones(size(idx2,2),1)] \ lnfactors2';
             * 
             * b = fit(1)
             * a = exp(fit(2))
             * in = str2num(get(handles.target_stayon,'String'));
             * out(2) = 100*(a*exp(b*(in)));
             * 
             * else
             * idx2(k,:) = find((Dstay(2,:)));   
             * lnfactors2 = log(factors(2,:));
             * fit = [((Dstay(2,:))/2.54)' ones(size(idx2,2),1)] \ lnfactors2';
             * 
             * b = fit(1)
             * a = exp(fit(2))
             * in = str2num(get(handles.target_stayon,'String'));
             * out(2) = 100*(a*exp(b*(in/2.54)));
             * 
             * 
             * 
             * 
             * 
             * 
             * 
             * 
             * 
             * 
             * end
             * 
             * end
             * 
             * end
             */
            for (; ; ) {
                if (mclEqBool(mlfScalar(v_), _mxarray0_)) {
                    mclArrayAssign2(
                      &factors,
                      _mxarray100_,
                      _mxarray0_,
                      mlfCreateColonIndex());
                } else {
                    mclArrayAssign2(
                      &factors,
                      mclVv(new_factors, "new_factors"),
                      _mxarray42_,
                      mlfCreateColonIndex());
                }
                {
                    int v_0 = mclForIntStart(1);
                    int e_0 = 5;
                    if (v_0 > e_0) {
                        mlfAssign(&i, _mxarray11_);
                    } else {
                        for (; ; ) {
                            mlfAssign(
                              &f,
                              mclIntArrayRef2(
                                mclVv(factors, "factors"), v_, v_0));
                            if (mclEqBool(mclVv(unit, "unit"), _mxarray42_)) {
                                mlfAssign(
                                  &Arg,
                                  mclMtimes(
                                    mclMtimes(
                                      mlfStr2num(
                                        NULL,
                                        mlfNGet(
                                          1,
                                          mlfIndexRef(
                                            mclVa(handles, "handles"),
                                            ".BasinArea"),
                                          _mxarray35_,
                                          NULL)),
                                      _mxarray102_),
                                    mclVv(f, "f")));
                                mclPrintArray(mclVv(Arg, "Arg"), "Arg");
                            } else {
                                mlfAssign(
                                  &Arg,
                                  mclMtimes(
                                    mlfStr2num(
                                      NULL,
                                      mlfNGet(
                                        1,
                                        mlfIndexRef(
                                          mclVa(handles, "handles"),
                                          ".BasinArea"),
                                        _mxarray35_,
                                        NULL)),
                                    mclVv(f, "f")));
                                mclPrintArray(mclVv(Arg, "Arg"), "Arg");
                            }
                            mlfAssign(
                              &EIA,
                              mlfStr2num(
                                NULL,
                                mlfNGet(
                                  1,
                                  mlfIndexRef(
                                    mclVa(handles, "handles"), ".ImpA"),
                                  _mxarray35_,
                                  NULL)));
                            mlfAssign(
                              &TribA,
                              mlfStr2num(
                                NULL,
                                mlfNGet(
                                  1,
                                  mlfIndexRef(
                                    mclVa(handles, "handles"), ".BasinArea"),
                                  _mxarray35_,
                                  NULL)));
                            mlfAssign(
                              &CN,
                              mlfStr2num(
                                NULL,
                                mlfNGet(
                                  1,
                                  mlfIndexRef(mclVa(handles, "handles"), ".CN"),
                                  _mxarray35_,
                                  NULL)));
                            mlfAssign(&Sd, _mxarray50_);
                            mlfAssign(
                              &avet,
                              mlfStr2num(
                                NULL,
                                mlfNGet(
                                  1,
                                  mlfIndexRef(
                                    mclVa(handles, "handles"), ".AveET"),
                                  _mxarray35_,
                                  NULL)));
                            if (mclEqBool(mclVv(unit, "unit"), _mxarray0_)) {
                                mlfAssign(
                                  &soilsdata,
                                  mlfDlmread(
                                    _mxarray51_,
                                    _mxarray53_,
                                    _mxarray55_,
                                    NULL,
                                    NULL));
                            } else {
                                mlfAssign(
                                  &soilsdata,
                                  mlfDlmread(
                                    _mxarray57_,
                                    _mxarray53_,
                                    _mxarray55_,
                                    NULL,
                                    NULL));
                            }
                            mlfAssign(
                              &soilnames,
                              mlfNTextread(
                                0,
                                mclValueVarargout(),
                                _mxarray59_,
                                _mxarray61_,
                                _mxarray63_,
                                _mxarray65_,
                                _mxarray67_,
                                _mxarray69_,
                                NULL));
                            mlfAssign(
                              &Nsoilnumber,
                              mlfNGet(
                                1,
                                mlfIndexRef(
                                  mclVa(handles, "handles"), ".NativeTexture"),
                                _mxarray44_,
                                NULL));
                            mlfAssign(
                              &Rsoilnumber,
                              mlfNGet(
                                1,
                                mlfIndexRef(
                                  mclVa(handles, "handles"), ".RootTexture"),
                                _mxarray44_,
                                NULL));
                            mlfAssign(
                              &Ssoilnumber,
                              mlfNGet(
                                1,
                                mlfIndexRef(
                                  mclVa(handles, "handles"), ".StorageTexture"),
                                _mxarray44_,
                                NULL));
                            mlfAssign(
                              &NTexture,
                              mclArrayRef2(
                                mclVv(soilnames, "soilnames"),
                                mclVv(Nsoilnumber, "Nsoilnumber"),
                                _mxarray0_));
                            mlfAssign(
                              &STexture,
                              mclArrayRef2(
                                mclVv(soilnames, "soilnames"),
                                mclVv(Ssoilnumber, "Ssoilnumber"),
                                _mxarray0_));
                            mlfAssign(
                              &RTexture,
                              mclArrayRef2(
                                mclVv(soilnames, "soilnames"),
                                mclVv(Rsoilnumber, "Rsoilnumber"),
                                _mxarray0_));
                            mlfAssign(
                              &dmin,
                              mlfStr2num(
                                NULL,
                                mlfNGet(
                                  1,
                                  mlfIndexRef(mclVa(handles, "handles"), ".Sd"),
                                  _mxarray35_,
                                  NULL)));
                            mlfAssign(
                              &St,
                              mlfStr2num(
                                NULL,
                                mlfNGet(
                                  1,
                                  mlfIndexRef(mclVa(handles, "handles"), ".St"),
                                  _mxarray35_,
                                  NULL)));
                            mlfAssign(
                              &Srz,
                              mlfStr2num(
                                NULL,
                                mlfNGet(
                                  1,
                                  mlfIndexRef(
                                    mclVa(handles, "handles"), ".Srz"),
                                  _mxarray35_,
                                  NULL)));
                            mlfAssign(&Scz, _mxarray70_);
                            mlfAssign(
                              &Kcz,
                              mlfStr2num(
                                NULL,
                                mlfNGet(
                                  1,
                                  mlfIndexRef(
                                    mclVa(handles, "handles"), ".Ksat"),
                                  _mxarray35_,
                                  NULL)));
                            mlfAssign(
                              &Krz,
                              mlfStr2num(
                                NULL,
                                mlfNGet(
                                  1,
                                  mlfIndexRef(
                                    mclVa(handles, "handles"), ".Kroot"),
                                  _mxarray35_,
                                  NULL)));
                            mlfAssign(
                              &Kst,
                              mlfStr2num(
                                NULL,
                                mlfNGet(
                                  1,
                                  mlfIndexRef(
                                    mclVa(handles, "handles"), ".Kstore"),
                                  _mxarray35_,
                                  NULL)));
                            if (mclEqBool(mclVv(St, "St"), _mxarray32_)) {
                                mlfAssign(&St, _mxarray71_);
                                mlfAssign(&Scz, _mxarray71_);
                                mlfAssign(&Kst, mclVv(Kcz, "Kcz"));
                                mlfAssign(
                                  &STexture, mclVv(NTexture, "NTexture"));
                            }
                            mlfAssign(
                              &Urate,
                              mlfStr2num(
                                NULL,
                                mlfNGet(
                                  1,
                                  mlfIndexRef(
                                    mclVa(handles, "handles"), ".UFlow"),
                                  _mxarray35_,
                                  NULL)));
                            mlfAssign(
                              &Umax,
                              mclMtimes(
                                mclMrdivide(mclVv(Urate, "Urate"), _mxarray37_),
                                mclMrdivide(mclVv(Arg, "Arg"), _mxarray38_)));
                            mlfAssign(
                              &HydroCalc,
                              mlfNGet(
                                1,
                                mlfIndexRef(
                                  mclVa(handles, "handles"), ".SimType"),
                                _mxarray44_,
                                NULL));
                            if (mclEqBool(
                                  mclVv(HydroCalc, "HydroCalc"), _mxarray42_)) {
                                mlfAssign(&rundays, _mxarray72_);
                            } else {
                                mlfAssign(
                                  &rundays,
                                  mlfStr2num(
                                    NULL,
                                    mlfNGet(
                                      1,
                                      mlfIndexRef(
                                        mclVa(handles, "handles"), ".Length"),
                                      _mxarray35_,
                                      NULL)));
                            }
                            mlfAssign(
                              &time,
                              mclMtimes(
                                mclMtimes(
                                  mclVv(rundays, "rundays"), _mxarray49_),
                                _mxarray73_));
                            mlfAssign(&dt, _mxarray74_);
                            mlfAssign(
                              &stime,
                              mclMrdivide(mclVv(time, "time"), _mxarray73_));
                            mlfAssign(
                              &dt, mclMrdivide(mclVv(dt, "dt"), _mxarray73_));
                            mlfAssign(
                              &outname,
                              mlfNGet(
                                1,
                                mlfIndexRef(
                                  mclVa(handles, "handles"), ".Output"),
                                _mxarray35_,
                                NULL));
                            mlfAssign(
                              &Summary,
                              mlfNGet(
                                1,
                                mlfIndexRef(
                                  mclVa(handles, "handles"), ".Summary"),
                                _mxarray44_,
                                NULL));
                            mlfAssign(
                              &Record,
                              mlfNGet(
                                1,
                                mlfIndexRef(
                                  mclVa(handles, "handles"), ".Record"),
                                _mxarray44_,
                                NULL));
                            mlfAssign(&fileext, _mxarray75_);
                            if (mclEqBool(
                                  mclVv(HydroCalc, "HydroCalc"), _mxarray0_)) {
                                mlfAssign(
                                  &filename,
                                  mlfNGet(
                                    1,
                                    mlfIndexRef(
                                      mclVa(handles, "handles"), ".Input"),
                                    _mxarray35_,
                                    NULL));
                                mlfAssign(
                                  &infile,
                                  mlfStrcat(
                                    mclVv(filename, "filename"),
                                    mclVv(fileext, "fileext"),
                                    NULL));
                                mlfAssign(
                                  &nprecip,
                                  mlfDlmread(
                                    mclVv(infile, "infile"),
                                    _mxarray53_,
                                    mlfHorzcat(
                                      _mxarray0_,
                                      _mxarray32_,
                                      mclPlus(
                                        mlfCeil(mclVv(stime, "stime")),
                                        _mxarray0_),
                                      _mxarray42_,
                                      NULL),
                                    NULL,
                                    NULL));
                                if (mclEqBool(
                                      mclVv(unit, "unit"), _mxarray0_)) {
                                    mclArrayAssign2(
                                      &nprecip,
                                      mclRdivide(
                                        mclArrayRef2(
                                          mclVv(nprecip, "nprecip"),
                                          mlfCreateColonIndex(),
                                          _mxarray42_),
                                        _mxarray70_),
                                      mlfCreateColonIndex(),
                                      _mxarray42_);
                                    mclArrayAssign2(
                                      &nprecip,
                                      mclRdivide(
                                        mclArrayRef2(
                                          mclVv(nprecip, "nprecip"),
                                          mlfCreateColonIndex(),
                                          _mxarray72_),
                                        _mxarray70_),
                                      mlfCreateColonIndex(),
                                      _mxarray72_);
                                } else {
                                }
                            } else if (mclEqBool(
                                         mclVv(HydroCalc, "HydroCalc"),
                                         _mxarray42_)) {
                                mlfAssign(
                                  &PptType,
                                  mlfNGet(
                                    1,
                                    mlfIndexRef(
                                      mclVa(handles, "handles"), ".PptType"),
                                    _mxarray44_,
                                    NULL));
                                if (mclEqBool(
                                      mclVv(PptType, "PptType"), _mxarray0_)) {
                                    mlfAssign(&PptName, _mxarray77_);
                                } else if (mclEqBool(
                                             mclVv(PptType, "PptType"),
                                             _mxarray42_)) {
                                    mlfAssign(&PptName, _mxarray79_);
                                } else if (mclEqBool(
                                             mclVv(PptType, "PptType"),
                                             _mxarray72_)) {
                                    mlfAssign(&PptName, _mxarray81_);
                                } else {
                                    mlfAssign(&PptName, _mxarray83_);
                                }
                                mlfAssign(
                                  &PptDepth,
                                  mlfStr2num(
                                    NULL,
                                    mlfNGet(
                                      1,
                                      mlfIndexRef(
                                        mclVa(handles, "handles"), ".PptDepth"),
                                      _mxarray35_,
                                      NULL)));
                                mlfAssign(
                                  &PptFile,
                                  mlfNum2str(
                                    mlfStrcat(
                                      mclVv(PptName, "PptName"),
                                      _mxarray75_,
                                      NULL),
                                    NULL));
                                mlfAssign(
                                  &nprecip,
                                  mlfDlmread(
                                    mclVv(PptFile, "PptFile"),
                                    _mxarray53_,
                                    mlfHorzcat(
                                      _mxarray0_,
                                      _mxarray32_,
                                      mclPlus(
                                        mlfCeil(mclVv(stime, "stime")),
                                        _mxarray0_),
                                      _mxarray42_,
                                      NULL),
                                    NULL,
                                    NULL));
                                mclArrayAssign2(
                                  &nprecip,
                                  mclTimes(
                                    mclArrayRef2(
                                      mclVv(nprecip, "nprecip"),
                                      mlfCreateColonIndex(),
                                      _mxarray42_),
                                    mclVv(PptDepth, "PptDepth")),
                                  mlfCreateColonIndex(),
                                  _mxarray42_);
                                mclArrayAssign2(
                                  &nprecip,
                                  mclMrdivide(
                                    mclTimes(
                                      mclArrayRef2(
                                        mclVv(nprecip, "nprecip"),
                                        mlfCreateColonIndex(),
                                        _mxarray72_),
                                      mclVv(avet, "avet")),
                                    _mxarray49_),
                                  mlfCreateColonIndex(),
                                  _mxarray72_);
                            } else {
                                mlfAssign(&Sd, _mxarray32_);
                                mlfAssign(&EIA, _mxarray37_);
                                mlfAssign(
                                  &filename,
                                  mlfNGet(
                                    1,
                                    mlfIndexRef(
                                      mclVa(handles, "handles"), ".Input"),
                                    _mxarray35_,
                                    NULL));
                                mlfAssign(
                                  &infile,
                                  mlfStrcat(
                                    mclVv(filename, "filename"),
                                    mclVv(fileext, "fileext"),
                                    NULL));
                                mlfAssign(
                                  &nprecip,
                                  mlfDlmread(
                                    mclVv(infile, "infile"),
                                    _mxarray53_,
                                    mlfHorzcat(
                                      _mxarray0_,
                                      _mxarray32_,
                                      mclPlus(
                                        mlfCeil(mclVv(stime, "stime")),
                                        _mxarray0_),
                                      _mxarray42_,
                                      NULL),
                                    NULL,
                                    NULL));
                                mclArrayAssign2(
                                  &nprecip,
                                  mclRdivide(
                                    mclArrayRef2(
                                      mclVv(nprecip, "nprecip"),
                                      mlfCreateColonIndex(),
                                      _mxarray42_),
                                    _mxarray70_),
                                  mlfCreateColonIndex(),
                                  _mxarray42_);
                                mclArrayAssign2(
                                  &nprecip,
                                  mclRdivide(
                                    mclArrayRef2(
                                      mclVv(nprecip, "nprecip"),
                                      mlfCreateColonIndex(),
                                      _mxarray72_),
                                    _mxarray70_),
                                  mlfCreateColonIndex(),
                                  _mxarray72_);
                            }
                            if (mclEqBool(mclVv(unit, "unit"), _mxarray0_)) {
                                mlfAssign(
                                  &Dprecip,
                                  mlfRecarga(
                                    &Dimp,
                                    &Dperv,
                                    &Drunon,
                                    &Drunoff,
                                    &Devap,
                                    &Drecharge,
                                    &Dudrain,
                                    &Dstore,
                                    &maxpond,
                                    &tstponded,
                                    &inot,
                                    mclVv(nprecip, "nprecip"),
                                    mclVv(Sd, "Sd"),
                                    mclVv(avet, "avet"),
                                    mclVv(rundays, "rundays"),
                                    mclVv(outname, "outname"),
                                    mclVv(Summary, "Summary"),
                                    mclVv(Record, "Record"),
                                    mclVv(dmin, "dmin"),
                                    mclVv(Srz, "Srz"),
                                    mclVv(St, "St"),
                                    mclVv(Rsoilnumber, "Rsoilnumber"),
                                    mclVv(Ssoilnumber, "Ssoilnumber"),
                                    mclVv(Nsoilnumber, "Nsoilnumber"),
                                    mclVv(Krz, "Krz"),
                                    mclVv(Kst, "Kst"),
                                    mclVv(Kcz, "Kcz"),
                                    mclVv(Urate, "Urate"),
                                    mclVv(CN, "CN"),
                                    mclVv(EIA, "EIA"),
                                    mclVv(Arg, "Arg"),
                                    mclVv(TribA, "TribA")));
                            } else {
                                mclArrayAssign2(
                                  &nprecip,
                                  mclTimes(
                                    mclArrayRef2(
                                      mclVv(nprecip, "nprecip"),
                                      mlfCreateColonIndex(),
                                      _mxarray42_),
                                    _mxarray85_),
                                  mlfCreateColonIndex(),
                                  _mxarray42_);
                                mclArrayAssign2(
                                  &nprecip,
                                  mclTimes(
                                    mclArrayRef2(
                                      mclVv(nprecip, "nprecip"),
                                      mlfCreateColonIndex(),
                                      _mxarray72_),
                                    _mxarray85_),
                                  mlfCreateColonIndex(),
                                  _mxarray72_);
                                mlfAssign(
                                  &Dprecip,
                                  mlfRecarga_us(
                                    &Dimp,
                                    &Dperv,
                                    &Drunon,
                                    &Drunoff,
                                    &Devap,
                                    &Drecharge,
                                    &Dudrain,
                                    &Dstore,
                                    &maxpond,
                                    &tstponded,
                                    &inot,
                                    mclVv(nprecip, "nprecip"),
                                    mclVv(Sd, "Sd"),
                                    mclVv(avet, "avet"),
                                    mclVv(rundays, "rundays"),
                                    mclVv(outname, "outname"),
                                    mclVv(Summary, "Summary"),
                                    mclVv(Record, "Record"),
                                    mclVv(dmin, "dmin"),
                                    mclVv(Srz, "Srz"),
                                    mclVv(St, "St"),
                                    mclVv(Rsoilnumber, "Rsoilnumber"),
                                    mclVv(Ssoilnumber, "Ssoilnumber"),
                                    mclVv(Nsoilnumber, "Nsoilnumber"),
                                    mclVv(Krz, "Krz"),
                                    mclVv(Kst, "Kst"),
                                    mclVv(Kcz, "Kcz"),
                                    mclVv(Urate, "Urate"),
                                    mclVv(CN, "CN"),
                                    mclVv(EIA, "EIA"),
                                    mclVv(Arg, "Arg"),
                                    mclVv(TribA, "TribA")));
                            }
                            mclIntArrayAssign2(
                              &Dstay,
                              mclMinus(
                                mclMinus(
                                  mclVv(Dprecip, "Dprecip"),
                                  mclVv(Drunoff, "Drunoff")),
                                mclVv(Dudrain, "Dudrain")),
                              v_,
                              v_0);
                            mclPrintArray(mclVv(Dstay, "Dstay"), "Dstay");
                            if (mlfTobool(mlfIspc())) {
                                mclAssignAns(
                                  &ans,
                                  mlfNSet(
                                    0,
                                    mclVa(hObject, "hObject"),
                                    _mxarray28_,
                                    _mxarray30_,
                                    NULL));
                            } else {
                                mclAssignAns(
                                  &ans,
                                  mlfNSet(
                                    0,
                                    mclVa(hObject, "hObject"),
                                    _mxarray28_,
                                    mlfNGet(1, _mxarray32_, _mxarray33_, NULL),
                                    NULL));
                            }
                            if (v_0 == e_0) {
                                break;
                            }
                            ++v_0;
                        }
                        mlfAssign(&i, mlfScalar(v_0));
                    }
                }
                if (mclEqBool(mlfScalar(v_), _mxarray0_)) {
                    if (mclEqBool(mclVv(unit, "unit"), _mxarray42_)) {
                        mclArrayAssign2(
                          &idx,
                          mlfFind(
                            NULL,
                            NULL,
                            mclGt(
                              mlfAbs(
                                mclMinus(
                                  mclArrayRef2(
                                    mclVv(Dstay, "Dstay"),
                                    mlfScalar(v_),
                                    mlfCreateColonIndex()),
                                  mclVv(Dprecip, "Dprecip"))),
                              _mxarray103_)),
                          mlfScalar(v_),
                          mlfCreateColonIndex());
                        mlfAssign(
                          &lnfactors,
                          mlfLog(
                            mclArrayRef1(
                              mclVv(factors, "factors"),
                              mclArrayRef2(
                                mclVv(idx, "idx"),
                                mlfScalar(v_),
                                mlfCreateColonIndex()))));
                        mlfAssign(
                          &fit,
                          mlfMldivide(
                            mlfHorzcat(
                              mlfCtranspose(
                                mclArrayRef1(
                                  mclVv(Dstay, "Dstay"),
                                  mclArrayRef2(
                                    mclVv(idx, "idx"),
                                    mlfScalar(v_),
                                    mlfCreateColonIndex()))),
                              mlfOnes(
                                mlfSize(
                                  mclValueVarargout(),
                                  mclArrayRef2(
                                    mclVv(idx, "idx"),
                                    mlfScalar(v_),
                                    mlfCreateColonIndex()),
                                  _mxarray42_),
                                _mxarray0_,
                                NULL),
                              NULL),
                            mlfCtranspose(mclVv(lnfactors, "lnfactors"))));
                        mclIntArrayAssign1(
                          &b, mclIntArrayRef1(mclVv(fit, "fit"), 1), v_);
                        mclPrintArray(mclVv(b, "b"), "b");
                        mclIntArrayAssign1(
                          &a,
                          mlfExp(mclIntArrayRef1(mclVv(fit, "fit"), 2)),
                          v_);
                        mclPrintArray(mclVv(a, "a"), "a");
                        mlfAssign(
                          &in,
                          mlfStr2num(
                            NULL,
                            mlfNGet(
                              1,
                              mlfIndexRef(
                                mclVa(handles, "handles"), ".target_stayon"),
                              _mxarray35_,
                              NULL)));
                        mclIntArrayAssign1(
                          &out,
                          mclMtimes(
                            mclIntArrayRef1(mclVv(a, "a"), v_),
                            mlfExp(
                              mclMtimes(
                                mclIntArrayRef1(mclVv(b, "b"), v_),
                                mclVv(in, "in")))),
                          v_);
                        mclPrintArray(mclVv(out, "out"), "out");
                        if (mclGtBool(
                              mclIntArrayRef1(mclVv(out, "out"), v_),
                              _mxarray104_)) {
                            mlfAssign(
                              &new_factors,
                              mlfHorzcat(
                                mclIntArrayRef1(mclVv(out, "out"), 1),
                                mclMinus(
                                  mclIntArrayRef1(mclVv(out, "out"), 1),
                                  _mxarray104_),
                                mclPlus(
                                  mclIntArrayRef1(mclVv(out, "out"), 1),
                                  _mxarray104_),
                                mclMinus(
                                  mclIntArrayRef1(mclVv(out, "out"), 1),
                                  _mxarray105_),
                                mclPlus(
                                  mclIntArrayRef1(mclVv(out, "out"), 1),
                                  _mxarray105_),
                                NULL));
                        } else {
                            mlfAssign(
                              &new_factors,
                              mlfHorzcat(
                                mclIntArrayRef1(mclVv(out, "out"), 1),
                                mclPlus(
                                  mclIntArrayRef1(mclVv(out, "out"), 1),
                                  _mxarray105_),
                                mclPlus(
                                  mclIntArrayRef1(mclVv(out, "out"), 1),
                                  _mxarray104_),
                                mclPlus(
                                  mclIntArrayRef1(mclVv(out, "out"), 1),
                                  _mxarray106_),
                                mclPlus(
                                  mclIntArrayRef1(mclVv(out, "out"), 1),
                                  _mxarray107_),
                                NULL));
                        }
                        mclPrintAns(
                          &ans,
                          mlfNAxes(
                            0,
                            mlfIndexRef(mclVa(handles, "handles"), ".axes9"),
                            NULL));
                        mclPrintAns(
                          &ans,
                          mlfNPlot(
                            0,
                            mclArrayRef2(
                              mclVv(Dstay, "Dstay"),
                              mlfScalar(v_),
                              mlfCreateColonIndex()),
                            mclMtimes(mclVv(factors, "factors"), _mxarray37_),
                            NULL));
                    } else {
                        mclArrayAssign2(
                          &idx,
                          mlfFind(
                            NULL,
                            NULL,
                            mclGt(
                              mlfAbs(
                                mclMinus(
                                  mclArrayRef2(
                                    mclVv(Dstay, "Dstay"),
                                    mlfScalar(v_),
                                    mlfCreateColonIndex()),
                                  mclVv(Dprecip, "Dprecip"))),
                              _mxarray103_)),
                          mlfScalar(v_),
                          mlfCreateColonIndex());
                        mlfAssign(
                          &lnfactors,
                          mlfLog(
                            mclArrayRef1(
                              mclVv(factors, "factors"),
                              mclArrayRef2(
                                mclVv(idx, "idx"),
                                mlfScalar(v_),
                                mlfCreateColonIndex()))));
                        mlfAssign(
                          &fit,
                          mlfMldivide(
                            mlfHorzcat(
                              mlfCtranspose(
                                mclMrdivide(
                                  mclArrayRef1(
                                    mclVv(Dstay, "Dstay"),
                                    mclArrayRef2(
                                      mclVv(idx, "idx"),
                                      mlfScalar(v_),
                                      mlfCreateColonIndex())),
                                  _mxarray85_)),
                              mlfOnes(
                                mlfSize(
                                  mclValueVarargout(),
                                  mclArrayRef2(
                                    mclVv(idx, "idx"),
                                    mlfScalar(v_),
                                    mlfCreateColonIndex()),
                                  _mxarray42_),
                                _mxarray0_,
                                NULL),
                              NULL),
                            mlfCtranspose(mclVv(lnfactors, "lnfactors"))));
                        mclIntArrayAssign1(
                          &b, mclIntArrayRef1(mclVv(fit, "fit"), 1), v_);
                        mclPrintArray(mclVv(b, "b"), "b");
                        mclIntArrayAssign1(
                          &a,
                          mlfExp(mclIntArrayRef1(mclVv(fit, "fit"), 2)),
                          v_);
                        mclPrintArray(mclVv(a, "a"), "a");
                        mlfAssign(
                          &in,
                          mlfStr2num(
                            NULL,
                            mlfNGet(
                              1,
                              mlfIndexRef(
                                mclVa(handles, "handles"), ".target_stayon"),
                              _mxarray35_,
                              NULL)));
                        mclIntArrayAssign1(
                          &out,
                          mclMtimes(
                            mclIntArrayRef1(mclVv(a, "a"), v_),
                            mlfExp(
                              mclMtimes(
                                mclIntArrayRef1(mclVv(b, "b"), v_),
                                mclMrdivide(mclVv(in, "in"), _mxarray85_)))),
                          v_);
                        mclPrintArray(mclVv(out, "out"), "out");
                        if (mclGtBool(
                              mclIntArrayRef1(mclVv(out, "out"), v_),
                              _mxarray104_)) {
                            mlfAssign(
                              &new_factors,
                              mlfHorzcat(
                                mclIntArrayRef1(mclVv(out, "out"), 1),
                                mclMinus(
                                  mclIntArrayRef1(mclVv(out, "out"), 1),
                                  _mxarray104_),
                                mclPlus(
                                  mclIntArrayRef1(mclVv(out, "out"), 1),
                                  _mxarray104_),
                                mclMinus(
                                  mclIntArrayRef1(mclVv(out, "out"), 1),
                                  _mxarray105_),
                                mclPlus(
                                  mclIntArrayRef1(mclVv(out, "out"), 1),
                                  _mxarray105_),
                                NULL));
                        } else {
                            mlfAssign(
                              &new_factors,
                              mlfHorzcat(
                                mclIntArrayRef1(mclVv(out, "out"), 1),
                                mclPlus(
                                  mclIntArrayRef1(mclVv(out, "out"), 1),
                                  _mxarray105_),
                                mclPlus(
                                  mclIntArrayRef1(mclVv(out, "out"), 1),
                                  _mxarray104_),
                                mclPlus(
                                  mclIntArrayRef1(mclVv(out, "out"), 1),
                                  _mxarray106_),
                                mclPlus(
                                  mclIntArrayRef1(mclVv(out, "out"), 1),
                                  _mxarray107_),
                                NULL));
                        }
                        mlfAssign(
                          &new_factors,
                          mlfHorzcat(
                            mclIntArrayRef1(mclVv(out, "out"), 1),
                            mclMinus(
                              mclIntArrayRef1(mclVv(out, "out"), 1),
                              _mxarray104_),
                            mclPlus(
                              mclIntArrayRef1(mclVv(out, "out"), 1),
                              _mxarray104_),
                            mclMinus(
                              mclIntArrayRef1(mclVv(out, "out"), 1),
                              _mxarray105_),
                            mclPlus(
                              mclIntArrayRef1(mclVv(out, "out"), 1),
                              _mxarray105_),
                            NULL));
                        mclPrintAns(
                          &ans,
                          mlfNAxes(
                            0,
                            mlfIndexRef(mclVa(handles, "handles"), ".axes9"),
                            NULL));
                        mclPrintAns(
                          &ans,
                          mlfNPlot(
                            0,
                            mclArrayRef2(
                              mclVv(Dstay, "Dstay"),
                              mlfScalar(v_),
                              mlfCreateColonIndex()),
                            mclMtimes(mclVv(factors, "factors"), _mxarray37_),
                            NULL));
                    }
                } else {
                    if (mclEqBool(mclVv(unit, "unit"), _mxarray42_)) {
                        mclArrayAssign2(
                          &idx2,
                          mlfFind(
                            NULL,
                            NULL,
                            mclArrayRef2(
                              mclVv(Dstay, "Dstay"),
                              _mxarray42_,
                              mlfCreateColonIndex())),
                          mlfScalar(v_),
                          mlfCreateColonIndex());
                        mlfAssign(
                          &lnfactors2,
                          mlfLog(
                            mclArrayRef2(
                              mclVv(factors, "factors"),
                              _mxarray42_,
                              mlfCreateColonIndex())));
                        mlfAssign(
                          &fit,
                          mlfMldivide(
                            mlfHorzcat(
                              mlfCtranspose(
                                mclArrayRef2(
                                  mclVv(Dstay, "Dstay"),
                                  _mxarray42_,
                                  mlfCreateColonIndex())),
                              mlfOnes(
                                mlfSize(
                                  mclValueVarargout(),
                                  mclVv(idx2, "idx2"),
                                  _mxarray42_),
                                _mxarray0_,
                                NULL),
                              NULL),
                            mlfCtranspose(mclVv(lnfactors2, "lnfactors2"))));
                        mlfAssign(&b, mclIntArrayRef1(mclVv(fit, "fit"), 1));
                        mclPrintArray(mclVv(b, "b"), "b");
                        mlfAssign(
                          &a, mlfExp(mclIntArrayRef1(mclVv(fit, "fit"), 2)));
                        mclPrintArray(mclVv(a, "a"), "a");
                        mlfAssign(
                          &in,
                          mlfStr2num(
                            NULL,
                            mlfNGet(
                              1,
                              mlfIndexRef(
                                mclVa(handles, "handles"), ".target_stayon"),
                              _mxarray35_,
                              NULL)));
                        mclIntArrayAssign1(
                          &out,
                          mclMtimes(
                            _mxarray37_,
                            mclMtimes(
                              mclVv(a, "a"),
                              mlfExp(
                                mclMtimes(mclVv(b, "b"), mclVv(in, "in"))))),
                          2);
                    } else {
                        mclArrayAssign2(
                          &idx2,
                          mlfFind(
                            NULL,
                            NULL,
                            mclArrayRef2(
                              mclVv(Dstay, "Dstay"),
                              _mxarray42_,
                              mlfCreateColonIndex())),
                          mlfScalar(v_),
                          mlfCreateColonIndex());
                        mlfAssign(
                          &lnfactors2,
                          mlfLog(
                            mclArrayRef2(
                              mclVv(factors, "factors"),
                              _mxarray42_,
                              mlfCreateColonIndex())));
                        mlfAssign(
                          &fit,
                          mlfMldivide(
                            mlfHorzcat(
                              mlfCtranspose(
                                mclMrdivide(
                                  mclArrayRef2(
                                    mclVv(Dstay, "Dstay"),
                                    _mxarray42_,
                                    mlfCreateColonIndex()),
                                  _mxarray85_)),
                              mlfOnes(
                                mlfSize(
                                  mclValueVarargout(),
                                  mclVv(idx2, "idx2"),
                                  _mxarray42_),
                                _mxarray0_,
                                NULL),
                              NULL),
                            mlfCtranspose(mclVv(lnfactors2, "lnfactors2"))));
                        mlfAssign(&b, mclIntArrayRef1(mclVv(fit, "fit"), 1));
                        mclPrintArray(mclVv(b, "b"), "b");
                        mlfAssign(
                          &a, mlfExp(mclIntArrayRef1(mclVv(fit, "fit"), 2)));
                        mclPrintArray(mclVv(a, "a"), "a");
                        mlfAssign(
                          &in,
                          mlfStr2num(
                            NULL,
                            mlfNGet(
                              1,
                              mlfIndexRef(
                                mclVa(handles, "handles"), ".target_stayon"),
                              _mxarray35_,
                              NULL)));
                        mclIntArrayAssign1(
                          &out,
                          mclMtimes(
                            _mxarray37_,
                            mclMtimes(
                              mclVv(a, "a"),
                              mlfExp(
                                mclMtimes(
                                  mclVv(b, "b"),
                                  mclMrdivide(mclVv(in, "in"), _mxarray85_))))),
                          2);
                    }
                }
                if (v_ == e_) {
                    break;
                }
                ++v_;
            }
            mlfAssign(&k, mlfScalar(v_));
        }
    }
    /*
     * 
     * 
     * set(handles.Estimate_FAR,'String',num2str(out(2)));
     */
    mclAssignAns(
      &ans,
      mlfNSet(
        0,
        mlfIndexRef(mclVa(handles, "handles"), ".Estimate_FAR"),
        _mxarray35_,
        mlfNum2str(mclIntArrayRef1(mclVv(out, "out"), 2), NULL),
        NULL));
    mxDestroyArray(unit);
    mxDestroyArray(k);
    mxDestroyArray(factors);
    mxDestroyArray(new_factors);
    mxDestroyArray(i);
    mxDestroyArray(f);
    mxDestroyArray(Arg);
    mxDestroyArray(EIA);
    mxDestroyArray(TribA);
    mxDestroyArray(CN);
    mxDestroyArray(Sd);
    mxDestroyArray(avet);
    mxDestroyArray(soilsdata);
    mxDestroyArray(soilnames);
    mxDestroyArray(Nsoilnumber);
    mxDestroyArray(Rsoilnumber);
    mxDestroyArray(Ssoilnumber);
    mxDestroyArray(NTexture);
    mxDestroyArray(STexture);
    mxDestroyArray(RTexture);
    mxDestroyArray(dmin);
    mxDestroyArray(St);
    mxDestroyArray(Srz);
    mxDestroyArray(Scz);
    mxDestroyArray(Kcz);
    mxDestroyArray(Krz);
    mxDestroyArray(Kst);
    mxDestroyArray(Urate);
    mxDestroyArray(Umax);
    mxDestroyArray(HydroCalc);
    mxDestroyArray(rundays);
    mxDestroyArray(time);
    mxDestroyArray(dt);
    mxDestroyArray(stime);
    mxDestroyArray(outname);
    mxDestroyArray(Summary);
    mxDestroyArray(Record);
    mxDestroyArray(fileext);
    mxDestroyArray(filename);
    mxDestroyArray(infile);
    mxDestroyArray(nprecip);
    mxDestroyArray(PptType);
    mxDestroyArray(PptName);
    mxDestroyArray(PptDepth);
    mxDestroyArray(PptFile);
    mxDestroyArray(Dprecip);
    mxDestroyArray(Dimp);
    mxDestroyArray(Dperv);
    mxDestroyArray(Drunon);
    mxDestroyArray(Drunoff);
    mxDestroyArray(Devap);
    mxDestroyArray(Drecharge);
    mxDestroyArray(Dudrain);
    mxDestroyArray(Dstore);
    mxDestroyArray(maxpond);
    mxDestroyArray(tstponded);
    mxDestroyArray(inot);
    mxDestroyArray(Dstay);
    mxDestroyArray(ans);
    mxDestroyArray(idx);
    mxDestroyArray(lnfactors);
    mxDestroyArray(fit);
    mxDestroyArray(b);
    mxDestroyArray(a);
    mxDestroyArray(in);
    mxDestroyArray(out);
    mxDestroyArray(idx2);
    mxDestroyArray(lnfactors2);
    mxDestroyArray(handles);
    mxDestroyArray(eventdata);
    mxDestroyArray(hObject);
    mclSetCurrentLocalFunctionTable(save_local_function_table_);
    /*
     * 
     * % --- Executes during object creation, after setting all properties.
     */
}

/*
 * The function "Mrecarga_2_3_target_stayon_CreateFcn" is the implementation
 * version of the "recarga_2_3/target_stayon_CreateFcn" M-function from file
 * "u:\final_recarga6\recarga\recarga_2_3.m" (lines 2196-2211). It contains the
 * actual compiled code for that M-function. It is a static function and must
 * only be called from one of the interface functions, appearing below.
 */
/*
 * function target_stayon_CreateFcn(hObject, eventdata, handles)
 */
static void Mrecarga_2_3_target_stayon_CreateFcn(mxArray * hObject,
                                                 mxArray * eventdata,
                                                 mxArray * handles) {
    mexLocalFunctionTable save_local_function_table_
      = mclSetCurrentLocalFunctionTable(&_local_function_table_recarga_2_3);
    mxArray * ans = NULL;
    mclCopyArray(&hObject);
    mclCopyArray(&eventdata);
    mclCopyArray(&handles);
    /*
     * % hObject    handle to target_stayon (see GCBO)
     * % eventdata  reserved - to be defined in a future version of MATLAB
     * % handles    empty - handles not created until after all CreateFcns called
     * 
     * % Hint: edit controls usually have a white background on Windows.
     * %       See ISPC and COMPUTER.
     * if ispc
     */
    if (mlfTobool(mlfIspc())) {
        /*
         * set(hObject,'BackgroundColor','white');
         */
        mclAssignAns(
          &ans,
          mlfNSet(
            0, mclVa(hObject, "hObject"), _mxarray28_, _mxarray30_, NULL));
    /*
     * else
     */
    } else {
        /*
         * set(hObject,'BackgroundColor',get(0,'defaultUicontrolBackgroundColor'));
         */
        mclAssignAns(
          &ans,
          mlfNSet(
            0,
            mclVa(hObject, "hObject"),
            _mxarray28_,
            mlfNGet(1, _mxarray32_, _mxarray33_, NULL),
            NULL));
    /*
     * end
     */
    }
    mxDestroyArray(ans);
    mxDestroyArray(handles);
    mxDestroyArray(eventdata);
    mxDestroyArray(hObject);
    mclSetCurrentLocalFunctionTable(save_local_function_table_);
    /*
     * 
     * 
     * 
     */
}

/*
 * The function "Mrecarga_2_3_target_stayon_Callback" is the implementation
 * version of the "recarga_2_3/target_stayon_Callback" M-function from file
 * "u:\final_recarga6\recarga\recarga_2_3.m" (lines 2211-2221). It contains the
 * actual compiled code for that M-function. It is a static function and must
 * only be called from one of the interface functions, appearing below.
 */
/*
 * function target_stayon_Callback(hObject, eventdata, handles)
 */
static void Mrecarga_2_3_target_stayon_Callback(mxArray * hObject,
                                                mxArray * eventdata,
                                                mxArray * handles) {
    mexLocalFunctionTable save_local_function_table_
      = mclSetCurrentLocalFunctionTable(&_local_function_table_recarga_2_3);
    mclCopyArray(&hObject);
    mclCopyArray(&eventdata);
    mclCopyArray(&handles);
    mxDestroyArray(handles);
    mxDestroyArray(eventdata);
    mxDestroyArray(hObject);
    mclSetCurrentLocalFunctionTable(save_local_function_table_);
    /*
     * % hObject    handle to target_stayon (see GCBO)
     * % eventdata  reserved - to be defined in a future version of MATLAB
     * % handles    structure with handles and user data (see GUIDATA)
     * 
     * % Hints: get(hObject,'String') returns contents of target_stayon as text
     * %        str2double(get(hObject,'String')) returns contents of target_stayon as a double
     * 
     * 
     * % --- Executes during object creation, after setting all properties.
     */
}

/*
 * The function "Mrecarga_2_3_Estimate_FAR_CreateFcn" is the implementation
 * version of the "recarga_2_3/Estimate_FAR_CreateFcn" M-function from file
 * "u:\final_recarga6\recarga\recarga_2_3.m" (lines 2221-2236). It contains the
 * actual compiled code for that M-function. It is a static function and must
 * only be called from one of the interface functions, appearing below.
 */
/*
 * function Estimate_FAR_CreateFcn(hObject, eventdata, handles)
 */
static void Mrecarga_2_3_Estimate_FAR_CreateFcn(mxArray * hObject,
                                                mxArray * eventdata,
                                                mxArray * handles) {
    mexLocalFunctionTable save_local_function_table_
      = mclSetCurrentLocalFunctionTable(&_local_function_table_recarga_2_3);
    mxArray * ans = NULL;
    mclCopyArray(&hObject);
    mclCopyArray(&eventdata);
    mclCopyArray(&handles);
    /*
     * % hObject    handle to Estimate_FAR (see GCBO)
     * % eventdata  reserved - to be defined in a future version of MATLAB
     * % handles    empty - handles not created until after all CreateFcns called
     * 
     * % Hint: edit controls usually have a white background on Windows.
     * %       See ISPC and COMPUTER.
     * if ispc
     */
    if (mlfTobool(mlfIspc())) {
        /*
         * set(hObject,'BackgroundColor','white');
         */
        mclAssignAns(
          &ans,
          mlfNSet(
            0, mclVa(hObject, "hObject"), _mxarray28_, _mxarray30_, NULL));
    /*
     * else
     */
    } else {
        /*
         * set(hObject,'BackgroundColor',get(0,'defaultUicontrolBackgroundColor'));
         */
        mclAssignAns(
          &ans,
          mlfNSet(
            0,
            mclVa(hObject, "hObject"),
            _mxarray28_,
            mlfNGet(1, _mxarray32_, _mxarray33_, NULL),
            NULL));
    /*
     * end
     */
    }
    mxDestroyArray(ans);
    mxDestroyArray(handles);
    mxDestroyArray(eventdata);
    mxDestroyArray(hObject);
    mclSetCurrentLocalFunctionTable(save_local_function_table_);
    /*
     * 
     * 
     * 
     */
}

/*
 * The function "Mrecarga_2_3_Estimate_FAR_Callback" is the implementation
 * version of the "recarga_2_3/Estimate_FAR_Callback" M-function from file
 * "u:\final_recarga6\recarga\recarga_2_3.m" (lines 2236-2246). It contains the
 * actual compiled code for that M-function. It is a static function and must
 * only be called from one of the interface functions, appearing below.
 */
/*
 * function Estimate_FAR_Callback(hObject, eventdata, handles)
 */
static void Mrecarga_2_3_Estimate_FAR_Callback(mxArray * hObject,
                                               mxArray * eventdata,
                                               mxArray * handles) {
    mexLocalFunctionTable save_local_function_table_
      = mclSetCurrentLocalFunctionTable(&_local_function_table_recarga_2_3);
    mclCopyArray(&hObject);
    mclCopyArray(&eventdata);
    mclCopyArray(&handles);
    mxDestroyArray(handles);
    mxDestroyArray(eventdata);
    mxDestroyArray(hObject);
    mclSetCurrentLocalFunctionTable(save_local_function_table_);
    /*
     * % hObject    handle to Estimate_FAR (see GCBO)
     * % eventdata  reserved - to be defined in a future version of MATLAB
     * % handles    structure with handles and user data (see GUIDATA)
     * 
     * % Hints: get(hObject,'String') returns contents of Estimate_FAR as text
     * %        str2double(get(hObject,'String')) returns contents of Estimate_FAR as a double
     * 
     * 
     * % --- Executes during object creation, after setting all properties.
     */
}

/*
 * The function "Mrecarga_2_3_axes5_CreateFcn" is the implementation version of
 * the "recarga_2_3/axes5_CreateFcn" M-function from file
 * "u:\final_recarga6\recarga\recarga_2_3.m" (lines 2246-2255). It contains the
 * actual compiled code for that M-function. It is a static function and must
 * only be called from one of the interface functions, appearing below.
 */
/*
 * function axes5_CreateFcn(hObject, eventdata, handles)
 */
static void Mrecarga_2_3_axes5_CreateFcn(mxArray * hObject,
                                         mxArray * eventdata,
                                         mxArray * handles) {
    mexLocalFunctionTable save_local_function_table_
      = mclSetCurrentLocalFunctionTable(&_local_function_table_recarga_2_3);
    mclCopyArray(&hObject);
    mclCopyArray(&eventdata);
    mclCopyArray(&handles);
    mxDestroyArray(handles);
    mxDestroyArray(eventdata);
    mxDestroyArray(hObject);
    mclSetCurrentLocalFunctionTable(save_local_function_table_);
    /*
     * % hObject    handle to axes5 (see GCBO)
     * % eventdata  reserved - to be defined in a future version of MATLAB
     * % handles    empty - handles not created until after all CreateFcns called
     * 
     * % Hint: place code in OpeningFcn to populate axes5
     * 
     * 
     * % --- Executes during object creation, after setting all properties.
     */
}

/*
 * The function "Mrecarga_2_3_axes9_CreateFcn" is the implementation version of
 * the "recarga_2_3/axes9_CreateFcn" M-function from file
 * "u:\final_recarga6\recarga\recarga_2_3.m" (lines 2255-2263). It contains the
 * actual compiled code for that M-function. It is a static function and must
 * only be called from one of the interface functions, appearing below.
 */
/*
 * function axes9_CreateFcn(hObject, eventdata, handles)
 */
static void Mrecarga_2_3_axes9_CreateFcn(mxArray * hObject,
                                         mxArray * eventdata,
                                         mxArray * handles) {
    mexLocalFunctionTable save_local_function_table_
      = mclSetCurrentLocalFunctionTable(&_local_function_table_recarga_2_3);
    mclCopyArray(&hObject);
    mclCopyArray(&eventdata);
    mclCopyArray(&handles);
    mxDestroyArray(handles);
    mxDestroyArray(eventdata);
    mxDestroyArray(hObject);
    mclSetCurrentLocalFunctionTable(save_local_function_table_);
    /*
     * % hObject    handle to axes9 (see GCBO)
     * % eventdata  reserved - to be defined in a future version of MATLAB
     * % handles    empty - handles not created until after all CreateFcns called
     * 
     * % Hint: place code in OpeningFcn to populate axes9
     * 
     * 
     */
}
