/*
 * MATLAB Compiler: 3.0
 * Date: Mon Sep 20 09:40:01 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_multiple" 
 */
#include "recarga_multiple.h"
#include "mwservices.h"
#include "dlmread.h"
#include "gui_mainfcn.h"
#include "guidata.h"
#include "libmatlbm.h"
#include "libmmfile.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_[15] = { 'B', 'a', 'c', 'k', 'g', 'r', 'o', 'u',
                                'n', 'd', 'C', 'o', 'l', 'o', 'r' };
static mxArray * _mxarray14_;

static mxChar _array17_[5] = { 'w', 'h', 'i', 't', 'e' };
static mxArray * _mxarray16_;
static mxArray * _mxarray18_;

static mxChar _array20_[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 * _mxarray19_;

static mxChar _array22_[5] = { 'V', 'a', 'l', 'u', 'e' };
static mxArray * _mxarray21_;
static mxArray * _mxarray23_;

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

static mxChar _array27_[6] = { 'S', 't', 'r', 'i', 'n', 'g' };
static mxArray * _mxarray26_;
static mxArray * _mxarray28_;
static mxArray * _mxarray29_;
static mxArray * _mxarray30_;
static mxArray * _mxarray31_;

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

static double _array35_[4] = { 0.0, 0.0, 0.0, 0.0 };
static mxArray * _mxarray34_;
static mxArray * _mxarray36_;

static mxChar _array38_[2] = { '%', 's' };
static mxArray * _mxarray37_;
static mxArray * _mxarray39_;
static mxArray * _mxarray40_;

static mxChar _array42_[9] = { 'd', 'e', 'l', 'i', 'm', 'i', 't', 'e', 'r' };
static mxArray * _mxarray41_;
static mxArray * _mxarray43_;
static mxArray * _mxarray44_;
static mxArray * _mxarray45_;
static mxArray * _mxarray46_;
static mxArray * _mxarray47_;
static mxArray * _mxarray48_;
static mxArray * _mxarray49_;

static mxChar _array51_[1] = { 'w' };
static mxArray * _mxarray50_;

static mxChar _array53_[2] = { 'a', 't' };
static mxArray * _mxarray52_;

static mxChar _array55_[137] = { 'S', 'd', 0x005c, 't', ' ', 'S', 'r', 0x005c,
                                 't', ' ', 'S', 't', 0x005c, 't', ' ', 'T', 'e',
                                 'x', 't', 'u', 'r', 'e', 0x005c, 't', ' ', 'K',
                                 'n', 0x005c, 't', ' ', 'K', 'u', 0x005c, 't',
                                 ' ', 'C', 'N', 0x005c, 't', ' ', 'E', 'I', 'A',
                                 0x005c, 't', ' ', 'R', 'd', 0x005c, 't', ' ',
                                 'P', 'r', 'e', 'c', 'i', 'p', 0x005c, 't', ' ',
                                 'R', 'u', 'n', 'o', 'n', 0x005c, 't', ' ', 'R',
                                 'u', 'n', 'o', 'f', 'f', 0x005c, 't', ' ', 'E',
                                 'v', 'a', 'p', 0x005c, 't', ' ', 'R', 'e', 'c',
                                 'h', 'a', 'r', 'g', 'e', 0x005c, 't', ' ', 'D',
                                 'r', 'a', 'i', 'n', 0x005c, 't', ' ', 'S', 't',
                                 'a', 'y', 'o', 'n', 0x005c, 't', ' ', 'm', 'a',
                                 'x', 'p', 'o', 'n', 'd', '(', 'h', 'r', ')',
                                 0x005c, 't', ' ', 'O', 'v', 'e', 'r', 'f', 'l',
                                 'o', 'w', 's', 0x005c, 'n' };
static mxArray * _mxarray54_;

static mxChar _array57_[143] = { '%', '6', '.', '3', 'f', 0x005c, 't', ' ',
                                 '%', '6', '.', '3', 'f', 0x005c, 't', ' ',
                                 '%', '6', '.', '3', 'f', 0x005c, 't', ' ',
                                 '%', '6', '.', '3', 'f', 0x005c, 't', ' ',
                                 '%', '6', '.', '3', 'f', 0x005c, 't', ' ',
                                 '%', '6', '.', '3', 'f', 0x005c, 't', ' ',
                                 '%', '6', '.', '3', 'f', 0x005c, 't', ' ',
                                 '%', '6', '.', '3', 'f', 0x005c, 't', ' ',
                                 '%', '6', '.', '3', 'f', 0x005c, 't', ' ',
                                 '%', '6', '.', '3', 'f', 0x005c, 't', ' ',
                                 '%', '6', '.', '3', 'f', 0x005c, 't', ' ',
                                 '%', '6', '.', '3', 'f', 0x005c, 't', ' ',
                                 '%', '6', '.', '3', 'f', 0x005c, 't', ' ',
                                 '%', '6', '.', '3', 'f', 0x005c, 't', ' ',
                                 '%', '6', '.', '3', 'f', 0x005c, 't', ' ',
                                 '%', '6', '.', '3', 'f', 0x005c, 't', ' ',
                                 '%', '6', '.', '3', 'f', 0x005c, 't', ' ',
                                 '%', '6', '.', '0', 'f', 0x005c, 'n' };
static mxArray * _mxarray56_;

static mxChar _array59_[9] = { 0x005c, 'n', 'F', 'i', 'l',
                               'e', 's', 0x005c, 'n' };
static mxArray * _mxarray58_;

static mxChar _array61_[7] = { '%', '1', '0', 's', ' ', 0x005c, 'n' };
static mxArray * _mxarray60_;

void InitializeModule_recarga_multiple(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(15, _array15_);
    _mxarray16_ = mclInitializeString(5, _array17_);
    _mxarray18_ = mclInitializeDouble(0.0);
    _mxarray19_ = mclInitializeString(31, _array20_);
    _mxarray21_ = mclInitializeString(5, _array22_);
    _mxarray23_ = mclInitializeDouble(.35);
    _mxarray24_ = mclInitializeString(4, _array25_);
    _mxarray26_ = mclInitializeString(6, _array27_);
    _mxarray28_ = mclInitializeDouble(2.0);
    _mxarray29_ = mclInitializeDouble(10.0);
    _mxarray30_ = mclInitializeDouble(15.0);
    _mxarray31_ = mclInitializeDouble(1000.0);
    _mxarray32_ = mclInitializeString(2, _array33_);
    _mxarray34_ = mclInitializeDoubleVector(1, 4, _array35_);
    _mxarray36_ = mclInitializeDouble(11.0);
    _mxarray37_ = mclInitializeString(2, _array38_);
    _mxarray39_ = mclInitializeDouble(12.0);
    _mxarray40_ = mclInitializeDouble(24.0);
    _mxarray41_ = mclInitializeString(9, _array42_);
    _mxarray43_ = mclInitializeDouble(18.0);
    _mxarray44_ = mclInitializeDouble(60.0);
    _mxarray45_ = mclInitializeDouble(3.0);
    _mxarray46_ = mclInitializeDouble(2.54);
    _mxarray47_ = mclInitializeDouble(.0002471027206009538);
    _mxarray48_ = mclInitializeDouble(10.76);
    _mxarray49_ = mclInitializeDouble(100.0);
    _mxarray50_ = mclInitializeString(1, _array51_);
    _mxarray52_ = mclInitializeString(2, _array53_);
    _mxarray54_ = mclInitializeString(137, _array55_);
    _mxarray56_ = mclInitializeString(143, _array57_);
    _mxarray58_ = mclInitializeString(9, _array59_);
    _mxarray60_ = mclInitializeString(7, _array61_);
}

void TerminateModule_recarga_multiple(void) {
    mxDestroyArray(_mxarray60_);
    mxDestroyArray(_mxarray58_);
    mxDestroyArray(_mxarray56_);
    mxDestroyArray(_mxarray54_);
    mxDestroyArray(_mxarray52_);
    mxDestroyArray(_mxarray50_);
    mxDestroyArray(_mxarray49_);
    mxDestroyArray(_mxarray48_);
    mxDestroyArray(_mxarray47_);
    mxDestroyArray(_mxarray46_);
    mxDestroyArray(_mxarray45_);
    mxDestroyArray(_mxarray44_);
    mxDestroyArray(_mxarray43_);
    mxDestroyArray(_mxarray41_);
    mxDestroyArray(_mxarray40_);
    mxDestroyArray(_mxarray39_);
    mxDestroyArray(_mxarray37_);
    mxDestroyArray(_mxarray36_);
    mxDestroyArray(_mxarray34_);
    mxDestroyArray(_mxarray32_);
    mxDestroyArray(_mxarray31_);
    mxDestroyArray(_mxarray30_);
    mxDestroyArray(_mxarray29_);
    mxDestroyArray(_mxarray28_);
    mxDestroyArray(_mxarray26_);
    mxDestroyArray(_mxarray24_);
    mxDestroyArray(_mxarray23_);
    mxDestroyArray(_mxarray21_);
    mxDestroyArray(_mxarray19_);
    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_multiple_RECARGA_Multiple_OpeningFcn(mxArray * hObject,
                                                            mxArray * eventdata,
                                                            mxArray * handles,
                                                            ...);
static void mlxRecarga_multiple_RECARGA_Multiple_OpeningFcn(int nlhs,
                                                            mxArray * plhs[],
                                                            int nrhs,
                                                            mxArray * prhs[]);
static mxArray * mlfRecarga_multiple_RECARGA_Multiple_OutputFcn(mlfVarargoutList * varargout,
                                                                mxArray * hObject,
                                                                mxArray * eventdata,
                                                                mxArray * handles);
static void mlxRecarga_multiple_RECARGA_Multiple_OutputFcn(int nlhs,
                                                           mxArray * plhs[],
                                                           int nrhs,
                                                           mxArray * prhs[]);
static void mlfRecarga_multiple_AveET_CreateFcn(mxArray * hObject,
                                                mxArray * eventdata,
                                                mxArray * handles);
static void mlxRecarga_multiple_AveET_CreateFcn(int nlhs,
                                                mxArray * plhs[],
                                                int nrhs,
                                                mxArray * prhs[]);
static void mlfRecarga_multiple_AveET_Callback(mxArray * hObject,
                                               mxArray * eventdata,
                                               mxArray * handles);
static void mlxRecarga_multiple_AveET_Callback(int nlhs,
                                               mxArray * plhs[],
                                               int nrhs,
                                               mxArray * prhs[]);
static void mlfRecarga_multiple_Input_CreateFcn(mxArray * hObject,
                                                mxArray * eventdata,
                                                mxArray * handles);
static void mlxRecarga_multiple_Input_CreateFcn(int nlhs,
                                                mxArray * plhs[],
                                                int nrhs,
                                                mxArray * prhs[]);
static void mlfRecarga_multiple_Input_Callback(mxArray * hObject,
                                               mxArray * eventdata,
                                               mxArray * handles);
static void mlxRecarga_multiple_Input_Callback(int nlhs,
                                               mxArray * plhs[],
                                               int nrhs,
                                               mxArray * prhs[]);
static void mlfRecarga_multiple_Length_CreateFcn(mxArray * hObject,
                                                 mxArray * eventdata,
                                                 mxArray * handles);
static void mlxRecarga_multiple_Length_CreateFcn(int nlhs,
                                                 mxArray * plhs[],
                                                 int nrhs,
                                                 mxArray * prhs[]);
static void mlfRecarga_multiple_Length_Callback(mxArray * hObject,
                                                mxArray * eventdata,
                                                mxArray * handles);
static void mlxRecarga_multiple_Length_Callback(int nlhs,
                                                mxArray * plhs[],
                                                int nrhs,
                                                mxArray * prhs[]);
static void mlfRecarga_multiple_Output_CreateFcn(mxArray * hObject,
                                                 mxArray * eventdata,
                                                 mxArray * handles);
static void mlxRecarga_multiple_Output_CreateFcn(int nlhs,
                                                 mxArray * plhs[],
                                                 int nrhs,
                                                 mxArray * prhs[]);
static void mlfRecarga_multiple_Output_Callback(mxArray * hObject,
                                                mxArray * eventdata,
                                                mxArray * handles);
static void mlxRecarga_multiple_Output_Callback(int nlhs,
                                                mxArray * plhs[],
                                                int nrhs,
                                                mxArray * prhs[]);
static void mlfRecarga_multiple_Name_CreateFcn(mxArray * hObject,
                                               mxArray * eventdata,
                                               mxArray * handles);
static void mlxRecarga_multiple_Name_CreateFcn(int nlhs,
                                               mxArray * plhs[],
                                               int nrhs,
                                               mxArray * prhs[]);
static void mlfRecarga_multiple_Name_Callback(mxArray * hObject,
                                              mxArray * eventdata,
                                              mxArray * handles);
static void mlxRecarga_multiple_Name_Callback(int nlhs,
                                              mxArray * plhs[],
                                              int nrhs,
                                              mxArray * prhs[]);
static void mlfRecarga_multiple_RGCalc_Callback(mxArray * hObject,
                                                mxArray * eventdata,
                                                mxArray * handles);
static void mlxRecarga_multiple_RGCalc_Callback(int nlhs,
                                                mxArray * plhs[],
                                                int nrhs,
                                                mxArray * prhs[]);
static void mlfRecarga_multiple_Process_CreateFcn(mxArray * hObject,
                                                  mxArray * eventdata,
                                                  mxArray * handles);
static void mlxRecarga_multiple_Process_CreateFcn(int nlhs,
                                                  mxArray * plhs[],
                                                  int nrhs,
                                                  mxArray * prhs[]);
static void mlfRecarga_multiple_Data_CreateFcn(mxArray * hObject,
                                               mxArray * eventdata,
                                               mxArray * handles);
static void mlxRecarga_multiple_Data_CreateFcn(int nlhs,
                                               mxArray * plhs[],
                                               int nrhs,
                                               mxArray * prhs[]);
static void mlfRecarga_multiple_Data_Callback(mxArray * hObject,
                                              mxArray * eventdata,
                                              mxArray * handles);
static void mlxRecarga_multiple_Data_Callback(int nlhs,
                                              mxArray * plhs[],
                                              int nrhs,
                                              mxArray * prhs[]);
static void mlfRecarga_multiple_Units_CreateFcn(mxArray * hObject,
                                                mxArray * eventdata,
                                                mxArray * handles);
static void mlxRecarga_multiple_Units_CreateFcn(int nlhs,
                                                mxArray * plhs[],
                                                int nrhs,
                                                mxArray * prhs[]);
static void mlfRecarga_multiple_Units_Callback(mxArray * hObject,
                                               mxArray * eventdata,
                                               mxArray * handles);
static void mlxRecarga_multiple_Units_Callback(int nlhs,
                                               mxArray * plhs[],
                                               int nrhs,
                                               mxArray * prhs[]);
static mxArray * Mrecarga_multiple(int nargout_, mxArray * varargin);
static void Mrecarga_multiple_RECARGA_Multiple_OpeningFcn(mxArray * hObject,
                                                          mxArray * eventdata,
                                                          mxArray * handles,
                                                          mxArray * varargin);
static mxArray * Mrecarga_multiple_RECARGA_Multiple_OutputFcn(int nargout_,
                                                              mxArray * hObject,
                                                              mxArray * eventdata,
                                                              mxArray * handles);
static void Mrecarga_multiple_AveET_CreateFcn(mxArray * hObject,
                                              mxArray * eventdata,
                                              mxArray * handles);
static void Mrecarga_multiple_AveET_Callback(mxArray * hObject,
                                             mxArray * eventdata,
                                             mxArray * handles);
static void Mrecarga_multiple_Input_CreateFcn(mxArray * hObject,
                                              mxArray * eventdata,
                                              mxArray * handles);
static void Mrecarga_multiple_Input_Callback(mxArray * hObject,
                                             mxArray * eventdata,
                                             mxArray * handles);
static void Mrecarga_multiple_Length_CreateFcn(mxArray * hObject,
                                               mxArray * eventdata,
                                               mxArray * handles);
static void Mrecarga_multiple_Length_Callback(mxArray * hObject,
                                              mxArray * eventdata,
                                              mxArray * handles);
static void Mrecarga_multiple_Output_CreateFcn(mxArray * hObject,
                                               mxArray * eventdata,
                                               mxArray * handles);
static void Mrecarga_multiple_Output_Callback(mxArray * hObject,
                                              mxArray * eventdata,
                                              mxArray * handles);
static void Mrecarga_multiple_Name_CreateFcn(mxArray * hObject,
                                             mxArray * eventdata,
                                             mxArray * handles);
static void Mrecarga_multiple_Name_Callback(mxArray * hObject,
                                            mxArray * eventdata,
                                            mxArray * handles);
static void Mrecarga_multiple_RGCalc_Callback(mxArray * hObject,
                                              mxArray * eventdata,
                                              mxArray * handles);
static void Mrecarga_multiple_Process_CreateFcn(mxArray * hObject,
                                                mxArray * eventdata,
                                                mxArray * handles);
static void Mrecarga_multiple_Data_CreateFcn(mxArray * hObject,
                                             mxArray * eventdata,
                                             mxArray * handles);
static void Mrecarga_multiple_Data_Callback(mxArray * hObject,
                                            mxArray * eventdata,
                                            mxArray * handles);
static void Mrecarga_multiple_Units_CreateFcn(mxArray * hObject,
                                              mxArray * eventdata,
                                              mxArray * handles);
static void Mrecarga_multiple_Units_Callback(mxArray * hObject,
                                             mxArray * eventdata,
                                             mxArray * handles);

static mexFunctionTableEntry local_function_table_[18]
  = { { "RECARGA_Multiple_OpeningFcn",
        mlxRecarga_multiple_RECARGA_Multiple_OpeningFcn, -4, 0, NULL },
      { "RECARGA_Multiple_OutputFcn",
        mlxRecarga_multiple_RECARGA_Multiple_OutputFcn, 3, -1, NULL },
      { "AveET_CreateFcn", mlxRecarga_multiple_AveET_CreateFcn, 3, 0, NULL },
      { "AveET_Callback", mlxRecarga_multiple_AveET_Callback, 3, 0, NULL },
      { "Input_CreateFcn", mlxRecarga_multiple_Input_CreateFcn, 3, 0, NULL },
      { "Input_Callback", mlxRecarga_multiple_Input_Callback, 3, 0, NULL },
      { "Length_CreateFcn", mlxRecarga_multiple_Length_CreateFcn, 3, 0, NULL },
      { "Length_Callback", mlxRecarga_multiple_Length_Callback, 3, 0, NULL },
      { "Output_CreateFcn", mlxRecarga_multiple_Output_CreateFcn, 3, 0, NULL },
      { "Output_Callback", mlxRecarga_multiple_Output_Callback, 3, 0, NULL },
      { "Name_CreateFcn", mlxRecarga_multiple_Name_CreateFcn, 3, 0, NULL },
      { "Name_Callback", mlxRecarga_multiple_Name_Callback, 3, 0, NULL },
      { "RGCalc_Callback", mlxRecarga_multiple_RGCalc_Callback, 3, 0, NULL },
      { "Process_CreateFcn",
        mlxRecarga_multiple_Process_CreateFcn, 3, 0, NULL },
      { "Data_CreateFcn", mlxRecarga_multiple_Data_CreateFcn, 3, 0, NULL },
      { "Data_Callback", mlxRecarga_multiple_Data_Callback, 3, 0, NULL },
      { "Units_CreateFcn", mlxRecarga_multiple_Units_CreateFcn, 3, 0, NULL },
      { "Units_Callback", mlxRecarga_multiple_Units_Callback, 3, 0, NULL } };

_mexLocalFunctionTable _local_function_table_recarga_multiple
  = { 18, local_function_table_ };

/*
 * The function "mlfNRecarga_multiple" contains the nargout interface for the
 * "recarga_multiple" M-function from file
 * "u:\final_recarga6\recarga\recarga_multiple.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_multiple(int nargout, mlfVarargoutList * varargout, ...) {
    mxArray * varargin = NULL;
    mlfVarargin(&varargin, varargout, 0);
    mlfEnterNewContext(0, -1, varargin);
    nargout += mclNargout(varargout);
    *mlfGetVarargoutCellPtr(varargout) = Mrecarga_multiple(nargout, varargin);
    mlfRestorePreviousContext(0, 0);
    mxDestroyArray(varargin);
    return mlfAssignOutputs(varargout);
}

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

/*
 * The function "mlfVRecarga_multiple" contains the void interface for the
 * "recarga_multiple" M-function from file
 * "u:\final_recarga6\recarga\recarga_multiple.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_multiple(mxArray * synthetic_varargin_argument, ...) {
    mxArray * varargin = NULL;
    mxArray * varargout = NULL;
    mlfVarargin(&varargin, synthetic_varargin_argument, 1);
    mlfEnterNewContext(0, -1, varargin);
    varargout = Mrecarga_multiple(0, synthetic_varargin_argument);
    mlfRestorePreviousContext(0, 0);
    mxDestroyArray(varargin);
}

/*
 * The function "mlxRecarga_multiple" contains the feval interface for the
 * "recarga_multiple" M-function from file
 * "u:\final_recarga6\recarga\recarga_multiple.m" (lines 1-48). The feval
 * function calls the implementation version of recarga_multiple through this
 * function. This function processes any input arguments and passes them to the
 * implementation version of the function, appearing above.
 */
void mlxRecarga_multiple(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_multiple(nlhs, mprhs[0]);
    mclAssignVarargoutCell(0, nlhs, plhs, mplhs[0]);
    mlfRestorePreviousContext(0, 0);
    mxDestroyArray(mprhs[0]);
}

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

/*
 * The function "mlxRecarga_multiple_RECARGA_Multiple_OpeningFcn" contains the
 * feval interface for the "recarga_multiple/RECARGA_Multiple_OpeningFcn"
 * M-function from file "u:\final_recarga6\recarga\recarga_multiple.m" (lines
 * 48-66). The feval function calls the implementation version of
 * recarga_multiple/RECARGA_Multiple_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_multiple_RECARGA_Multiple_OpeningFcn(int nlhs,
                                                            mxArray * plhs[],
                                                            int nrhs,
                                                            mxArray * prhs[]) {
    mxArray * mprhs[4];
    int i;
    if (nlhs > 0) {
        mlfError(
          mxCreateString(
            "Run-time Error: File: recarga_multiple/RECARGA_Multip"
            "le_OpeningFcn Line: 48 Column: 1 The function \"recar"
            "ga_multiple/RECARGA_Multiple_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_multiple_RECARGA_Multiple_OpeningFcn(
      mprhs[0], mprhs[1], mprhs[2], mprhs[3]);
    mlfRestorePreviousContext(0, 3, mprhs[0], mprhs[1], mprhs[2]);
    mxDestroyArray(mprhs[3]);
}

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

/*
 * The function "mlxRecarga_multiple_RECARGA_Multiple_OutputFcn" contains the
 * feval interface for the "recarga_multiple/RECARGA_Multiple_OutputFcn"
 * M-function from file "u:\final_recarga6\recarga\recarga_multiple.m" (lines
 * 66-77). The feval function calls the implementation version of
 * recarga_multiple/RECARGA_Multiple_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_multiple_RECARGA_Multiple_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_multiple/RECARGA_Multi"
            "ple_OutputFcn Line: 66 Column: 1 The function \"reca"
            "rga_multiple/RECARGA_Multiple_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_multiple_RECARGA_Multiple_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_multiple_AveET_CreateFcn" contains the normal
 * interface for the "recarga_multiple/AveET_CreateFcn" M-function from file
 * "u:\final_recarga6\recarga\recarga_multiple.m" (lines 77-92). This function
 * processes any input arguments and passes them to the implementation version
 * of the function, appearing above.
 */
static void mlfRecarga_multiple_AveET_CreateFcn(mxArray * hObject,
                                                mxArray * eventdata,
                                                mxArray * handles) {
    mlfEnterNewContext(0, 3, hObject, eventdata, handles);
    Mrecarga_multiple_AveET_CreateFcn(hObject, eventdata, handles);
    mlfRestorePreviousContext(0, 3, hObject, eventdata, handles);
}

/*
 * The function "mlxRecarga_multiple_AveET_CreateFcn" contains the feval
 * interface for the "recarga_multiple/AveET_CreateFcn" M-function from file
 * "u:\final_recarga6\recarga\recarga_multiple.m" (lines 77-92). The feval
 * function calls the implementation version of
 * recarga_multiple/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_multiple_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_multiple/AveET_CreateFcn Line: 77"
            " Column: 1 The function \"recarga_multiple/AveET_CreateFcn\" wa"
            "s called with more than the declared number of outputs (0)."),
          NULL);
    }
    if (nrhs > 3) {
        mlfError(
          mxCreateString(
            "Run-time Error: File: recarga_multiple/AveET_CreateFcn Line: 7"
            "7 Column: 1 The function \"recarga_multiple/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_multiple_AveET_CreateFcn(mprhs[0], mprhs[1], mprhs[2]);
    mlfRestorePreviousContext(0, 3, mprhs[0], mprhs[1], mprhs[2]);
}

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

/*
 * The function "mlxRecarga_multiple_AveET_Callback" contains the feval
 * interface for the "recarga_multiple/AveET_Callback" M-function from file
 * "u:\final_recarga6\recarga\recarga_multiple.m" (lines 92-103). The feval
 * function calls the implementation version of recarga_multiple/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_multiple_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_multiple/AveET_Callback Line: 92"
            " Column: 1 The function \"recarga_multiple/AveET_Callback\" wa"
            "s called with more than the declared number of outputs (0)."),
          NULL);
    }
    if (nrhs > 3) {
        mlfError(
          mxCreateString(
            "Run-time Error: File: recarga_multiple/AveET_Callback Line: 92"
            " Column: 1 The function \"recarga_multiple/AveET_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_multiple_AveET_Callback(mprhs[0], mprhs[1], mprhs[2]);
    mlfRestorePreviousContext(0, 3, mprhs[0], mprhs[1], mprhs[2]);
}

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

/*
 * The function "mlxRecarga_multiple_Input_CreateFcn" contains the feval
 * interface for the "recarga_multiple/Input_CreateFcn" M-function from file
 * "u:\final_recarga6\recarga\recarga_multiple.m" (lines 103-118). The feval
 * function calls the implementation version of
 * recarga_multiple/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_multiple_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_multiple/Input_CreateFcn Line: 10"
            "3 Column: 1 The function \"recarga_multiple/Input_CreateFcn\" w"
            "as called with more than the declared number of outputs (0)."),
          NULL);
    }
    if (nrhs > 3) {
        mlfError(
          mxCreateString(
            "Run-time Error: File: recarga_multiple/Input_CreateFcn Line: 10"
            "3 Column: 1 The function \"recarga_multiple/Input_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_multiple_Input_CreateFcn(mprhs[0], mprhs[1], mprhs[2]);
    mlfRestorePreviousContext(0, 3, mprhs[0], mprhs[1], mprhs[2]);
}

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

/*
 * The function "mlxRecarga_multiple_Input_Callback" contains the feval
 * interface for the "recarga_multiple/Input_Callback" M-function from file
 * "u:\final_recarga6\recarga\recarga_multiple.m" (lines 118-130). The feval
 * function calls the implementation version of recarga_multiple/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_multiple_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_multiple/Input_Callback Line: 11"
            "8 Column: 1 The function \"recarga_multiple/Input_Callback\" w"
            "as called with more than the declared number of outputs (0)."),
          NULL);
    }
    if (nrhs > 3) {
        mlfError(
          mxCreateString(
            "Run-time Error: File: recarga_multiple/Input_Callback Line: 11"
            "8 Column: 1 The function \"recarga_multiple/Input_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_multiple_Input_Callback(mprhs[0], mprhs[1], mprhs[2]);
    mlfRestorePreviousContext(0, 3, mprhs[0], mprhs[1], mprhs[2]);
}

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

/*
 * The function "mlxRecarga_multiple_Length_CreateFcn" contains the feval
 * interface for the "recarga_multiple/Length_CreateFcn" M-function from file
 * "u:\final_recarga6\recarga\recarga_multiple.m" (lines 130-145). The feval
 * function calls the implementation version of
 * recarga_multiple/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_multiple_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_multiple/Length_CreateFcn Line: 13"
            "0 Column: 1 The function \"recarga_multiple/Length_CreateFcn\" w"
            "as called with more than the declared number of outputs (0)."),
          NULL);
    }
    if (nrhs > 3) {
        mlfError(
          mxCreateString(
            "Run-time Error: File: recarga_multiple/Length_CreateFcn Line: 1"
            "30 Column: 1 The function \"recarga_multiple/Length_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_multiple_Length_CreateFcn(mprhs[0], mprhs[1], mprhs[2]);
    mlfRestorePreviousContext(0, 3, mprhs[0], mprhs[1], mprhs[2]);
}

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

/*
 * The function "mlxRecarga_multiple_Length_Callback" contains the feval
 * interface for the "recarga_multiple/Length_Callback" M-function from file
 * "u:\final_recarga6\recarga\recarga_multiple.m" (lines 145-155). The feval
 * function calls the implementation version of
 * recarga_multiple/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_multiple_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_multiple/Length_Callback Line: 14"
            "5 Column: 1 The function \"recarga_multiple/Length_Callback\" w"
            "as called with more than the declared number of outputs (0)."),
          NULL);
    }
    if (nrhs > 3) {
        mlfError(
          mxCreateString(
            "Run-time Error: File: recarga_multiple/Length_Callback Line: 14"
            "5 Column: 1 The function \"recarga_multiple/Length_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_multiple_Length_Callback(mprhs[0], mprhs[1], mprhs[2]);
    mlfRestorePreviousContext(0, 3, mprhs[0], mprhs[1], mprhs[2]);
}

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

/*
 * The function "mlxRecarga_multiple_Output_CreateFcn" contains the feval
 * interface for the "recarga_multiple/Output_CreateFcn" M-function from file
 * "u:\final_recarga6\recarga\recarga_multiple.m" (lines 155-170). The feval
 * function calls the implementation version of
 * recarga_multiple/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_multiple_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_multiple/Output_CreateFcn Line: 15"
            "5 Column: 1 The function \"recarga_multiple/Output_CreateFcn\" w"
            "as called with more than the declared number of outputs (0)."),
          NULL);
    }
    if (nrhs > 3) {
        mlfError(
          mxCreateString(
            "Run-time Error: File: recarga_multiple/Output_CreateFcn Line: 1"
            "55 Column: 1 The function \"recarga_multiple/Output_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_multiple_Output_CreateFcn(mprhs[0], mprhs[1], mprhs[2]);
    mlfRestorePreviousContext(0, 3, mprhs[0], mprhs[1], mprhs[2]);
}

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

/*
 * The function "mlxRecarga_multiple_Output_Callback" contains the feval
 * interface for the "recarga_multiple/Output_Callback" M-function from file
 * "u:\final_recarga6\recarga\recarga_multiple.m" (lines 170-180). The feval
 * function calls the implementation version of
 * recarga_multiple/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_multiple_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_multiple/Output_Callback Line: 17"
            "0 Column: 1 The function \"recarga_multiple/Output_Callback\" w"
            "as called with more than the declared number of outputs (0)."),
          NULL);
    }
    if (nrhs > 3) {
        mlfError(
          mxCreateString(
            "Run-time Error: File: recarga_multiple/Output_Callback Line: 17"
            "0 Column: 1 The function \"recarga_multiple/Output_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_multiple_Output_Callback(mprhs[0], mprhs[1], mprhs[2]);
    mlfRestorePreviousContext(0, 3, mprhs[0], mprhs[1], mprhs[2]);
}

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

/*
 * The function "mlxRecarga_multiple_Name_CreateFcn" contains the feval
 * interface for the "recarga_multiple/Name_CreateFcn" M-function from file
 * "u:\final_recarga6\recarga\recarga_multiple.m" (lines 180-195). The feval
 * function calls the implementation version of recarga_multiple/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_multiple_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_multiple/Name_CreateFcn Line: 18"
            "0 Column: 1 The function \"recarga_multiple/Name_CreateFcn\" w"
            "as called with more than the declared number of outputs (0)."),
          NULL);
    }
    if (nrhs > 3) {
        mlfError(
          mxCreateString(
            "Run-time Error: File: recarga_multiple/Name_CreateFcn Line: 18"
            "0 Column: 1 The function \"recarga_multiple/Name_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_multiple_Name_CreateFcn(mprhs[0], mprhs[1], mprhs[2]);
    mlfRestorePreviousContext(0, 3, mprhs[0], mprhs[1], mprhs[2]);
}

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

/*
 * The function "mlxRecarga_multiple_Name_Callback" contains the feval
 * interface for the "recarga_multiple/Name_Callback" M-function from file
 * "u:\final_recarga6\recarga\recarga_multiple.m" (lines 195-205). The feval
 * function calls the implementation version of recarga_multiple/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_multiple_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_multiple/Name_Callback Line: 195"
            " Column: 1 The function \"recarga_multiple/Name_Callback\" was"
            " called with more than the declared number of outputs (0)."),
          NULL);
    }
    if (nrhs > 3) {
        mlfError(
          mxCreateString(
            "Run-time Error: File: recarga_multiple/Name_Callback Line: 19"
            "5 Column: 1 The function \"recarga_multiple/Name_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_multiple_Name_Callback(mprhs[0], mprhs[1], mprhs[2]);
    mlfRestorePreviousContext(0, 3, mprhs[0], mprhs[1], mprhs[2]);
}

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

/*
 * The function "mlxRecarga_multiple_RGCalc_Callback" contains the feval
 * interface for the "recarga_multiple/RGCalc_Callback" M-function from file
 * "u:\final_recarga6\recarga\recarga_multiple.m" (lines 205-294). The feval
 * function calls the implementation version of
 * recarga_multiple/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_multiple_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_multiple/RGCalc_Callback Line: 20"
            "5 Column: 1 The function \"recarga_multiple/RGCalc_Callback\" w"
            "as called with more than the declared number of outputs (0)."),
          NULL);
    }
    if (nrhs > 3) {
        mlfError(
          mxCreateString(
            "Run-time Error: File: recarga_multiple/RGCalc_Callback Line: 20"
            "5 Column: 1 The function \"recarga_multiple/RGCalc_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_multiple_RGCalc_Callback(mprhs[0], mprhs[1], mprhs[2]);
    mlfRestorePreviousContext(0, 3, mprhs[0], mprhs[1], mprhs[2]);
}

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

/*
 * The function "mlxRecarga_multiple_Process_CreateFcn" contains the feval
 * interface for the "recarga_multiple/Process_CreateFcn" M-function from file
 * "u:\final_recarga6\recarga\recarga_multiple.m" (lines 294-308). The feval
 * function calls the implementation version of
 * recarga_multiple/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_multiple_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_multiple/Process_CreateFcn Line: 2"
            "94 Column: 1 The function \"recarga_multiple/Process_CreateFcn\""
            " was called with more than the declared number of outputs (0)."),
          NULL);
    }
    if (nrhs > 3) {
        mlfError(
          mxCreateString(
            "Run-time Error: File: recarga_multiple/Process_CreateFcn Line: 2"
            "94 Column: 1 The function \"recarga_multiple/Process_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_multiple_Process_CreateFcn(mprhs[0], mprhs[1], mprhs[2]);
    mlfRestorePreviousContext(0, 3, mprhs[0], mprhs[1], mprhs[2]);
}

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

/*
 * The function "mlxRecarga_multiple_Data_CreateFcn" contains the feval
 * interface for the "recarga_multiple/Data_CreateFcn" M-function from file
 * "u:\final_recarga6\recarga\recarga_multiple.m" (lines 308-323). The feval
 * function calls the implementation version of recarga_multiple/Data_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_multiple_Data_CreateFcn(int nlhs,
                                               mxArray * plhs[],
                                               int nrhs,
                                               mxArray * prhs[]) {
    mxArray * mprhs[3];
    int i;
    if (nlhs > 0) {
        mlfError(
          mxCreateString(
            "Run-time Error: File: recarga_multiple/Data_CreateFcn Line: 30"
            "8 Column: 1 The function \"recarga_multiple/Data_CreateFcn\" w"
            "as called with more than the declared number of outputs (0)."),
          NULL);
    }
    if (nrhs > 3) {
        mlfError(
          mxCreateString(
            "Run-time Error: File: recarga_multiple/Data_CreateFcn Line: 30"
            "8 Column: 1 The function \"recarga_multiple/Data_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_multiple_Data_CreateFcn(mprhs[0], mprhs[1], mprhs[2]);
    mlfRestorePreviousContext(0, 3, mprhs[0], mprhs[1], mprhs[2]);
}

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

/*
 * The function "mlxRecarga_multiple_Data_Callback" contains the feval
 * interface for the "recarga_multiple/Data_Callback" M-function from file
 * "u:\final_recarga6\recarga\recarga_multiple.m" (lines 323-333). The feval
 * function calls the implementation version of recarga_multiple/Data_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_multiple_Data_Callback(int nlhs,
                                              mxArray * plhs[],
                                              int nrhs,
                                              mxArray * prhs[]) {
    mxArray * mprhs[3];
    int i;
    if (nlhs > 0) {
        mlfError(
          mxCreateString(
            "Run-time Error: File: recarga_multiple/Data_Callback Line: 323"
            " Column: 1 The function \"recarga_multiple/Data_Callback\" was"
            " called with more than the declared number of outputs (0)."),
          NULL);
    }
    if (nrhs > 3) {
        mlfError(
          mxCreateString(
            "Run-time Error: File: recarga_multiple/Data_Callback Line: 32"
            "3 Column: 1 The function \"recarga_multiple/Data_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_multiple_Data_Callback(mprhs[0], mprhs[1], mprhs[2]);
    mlfRestorePreviousContext(0, 3, mprhs[0], mprhs[1], mprhs[2]);
}

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

/*
 * The function "mlxRecarga_multiple_Units_CreateFcn" contains the feval
 * interface for the "recarga_multiple/Units_CreateFcn" M-function from file
 * "u:\final_recarga6\recarga\recarga_multiple.m" (lines 333-348). The feval
 * function calls the implementation version of
 * recarga_multiple/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_multiple_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_multiple/Units_CreateFcn Line: 33"
            "3 Column: 1 The function \"recarga_multiple/Units_CreateFcn\" w"
            "as called with more than the declared number of outputs (0)."),
          NULL);
    }
    if (nrhs > 3) {
        mlfError(
          mxCreateString(
            "Run-time Error: File: recarga_multiple/Units_CreateFcn Line: 33"
            "3 Column: 1 The function \"recarga_multiple/Units_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_multiple_Units_CreateFcn(mprhs[0], mprhs[1], mprhs[2]);
    mlfRestorePreviousContext(0, 3, mprhs[0], mprhs[1], mprhs[2]);
}

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

/*
 * The function "mlxRecarga_multiple_Units_Callback" contains the feval
 * interface for the "recarga_multiple/Units_Callback" M-function from file
 * "u:\final_recarga6\recarga\recarga_multiple.m" (lines 348-357). The feval
 * function calls the implementation version of recarga_multiple/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_multiple_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_multiple/Units_Callback Line: 34"
            "8 Column: 1 The function \"recarga_multiple/Units_Callback\" w"
            "as called with more than the declared number of outputs (0)."),
          NULL);
    }
    if (nrhs > 3) {
        mlfError(
          mxCreateString(
            "Run-time Error: File: recarga_multiple/Units_Callback Line: 34"
            "8 Column: 1 The function \"recarga_multiple/Units_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_multiple_Units_Callback(mprhs[0], mprhs[1], mprhs[2]);
    mlfRestorePreviousContext(0, 3, mprhs[0], mprhs[1], mprhs[2]);
}

/*
 * The function "Mrecarga_multiple" is the implementation version of the
 * "recarga_multiple" M-function from file
 * "u:\final_recarga6\recarga\recarga_multiple.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_Multiple(varargin)
 */
static mxArray * Mrecarga_multiple(int nargout_, mxArray * varargin) {
    mexLocalFunctionTable save_local_function_table_
      = mclSetCurrentLocalFunctionTable(
          &_local_function_table_recarga_multiple);
    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_MULTIPLE M-file for RECARGA_Multiple.fig
     * %      RECARGA_MULTIPLE, by itself, creates a new RECARGA_MULTIPLE or raises the existing
     * %      singleton*.
     * %
     * %      H = RECARGA_MULTIPLE returns the handle to a new RECARGA_MULTIPLE or the handle to
     * %      the existing singleton*.
     * %
     * %      RECARGA_MULTIPLE('CALLBACK',hObject,eventData,handles,...) calls the local
     * %      function named CALLBACK in RECARGA_MULTIPLE.M with the given input arguments.
     * %
     * %      RECARGA_MULTIPLE('Property','Value',...) creates a new RECARGA_MULTIPLE or raises the
     * %      existing singleton*.  Starting from the left, property value pairs are
     * %      applied to the GUI before RECARGA_Multiple_OpeningFunction gets called.  An
     * %      unrecognized property input or invalid value makes property application
     * %      stop.  All inputs are passed to RECARGA_Multiple_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_Multiple
     * 
     * % Last Modified by GUIDE v2.5 19-May-2004 13:54:28
     * 
     * % 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_multiple"),
        _mxarray3_,
        mclVv(gui_Singleton, "gui_Singleton"),
        _mxarray5_,
        mclCreateSimpleFunctionHandle(
          mlxRecarga_multiple_RECARGA_Multiple_OpeningFcn,
          "RECARGA_Multiple_OpeningFcn"),
        _mxarray7_,
        mclCreateSimpleFunctionHandle(
          mlxRecarga_multiple_RECARGA_Multiple_OutputFcn,
          "RECARGA_Multiple_OutputFcn"),
        _mxarray9_,
        _mxarray11_,
        _mxarray12_,
        _mxarray11_,
        NULL));
    /*
     * 'gui_Singleton',  gui_Singleton, ...
     * 'gui_OpeningFcn', @RECARGA_Multiple_OpeningFcn, ...
     * 'gui_OutputFcn',  @RECARGA_Multiple_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_Multiple is made visible.
     */
}

/*
 * The function "Mrecarga_multiple_RECARGA_Multiple_OpeningFcn" is the
 * implementation version of the "recarga_multiple/RECARGA_Multiple_OpeningFcn"
 * M-function from file "u:\final_recarga6\recarga\recarga_multiple.m" (lines
 * 48-66). 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_Multiple_OpeningFcn(hObject, eventdata, handles, varargin)
 */
static void Mrecarga_multiple_RECARGA_Multiple_OpeningFcn(mxArray * hObject,
                                                          mxArray * eventdata,
                                                          mxArray * handles,
                                                          mxArray * varargin) {
    mexLocalFunctionTable save_local_function_table_
      = mclSetCurrentLocalFunctionTable(
          &_local_function_table_recarga_multiple);
    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 input (see GUIDATA)
     * % varargin   command line arguments to RECARGA_Multiple (see VARARGIN)
     * 
     * % Choose default command line output for RECARGA_Multiple
     * 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")));
    mxDestroyArray(ans);
    mxDestroyArray(varargin);
    mxDestroyArray(handles);
    mxDestroyArray(eventdata);
    mxDestroyArray(hObject);
    mclSetCurrentLocalFunctionTable(save_local_function_table_);
    /*
     * 
     * % UIWAIT makes RECARGA_Multiple wait for user response (see UIRESUME)
     * % uiwait(handles.figure1);
     * 
     * 
     * % --- Outputs from this function are returned to the command line.
     */
}

/*
 * The function "Mrecarga_multiple_RECARGA_Multiple_OutputFcn" is the
 * implementation version of the "recarga_multiple/RECARGA_Multiple_OutputFcn"
 * M-function from file "u:\final_recarga6\recarga\recarga_multiple.m" (lines
 * 66-77). 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_Multiple_OutputFcn(hObject, eventdata, handles)
 */
static mxArray * Mrecarga_multiple_RECARGA_Multiple_OutputFcn(int nargout_,
                                                              mxArray * hObject,
                                                              mxArray * eventdata,
                                                              mxArray * handles) {
    mexLocalFunctionTable save_local_function_table_
      = mclSetCurrentLocalFunctionTable(
          &_local_function_table_recarga_multiple);
    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 input (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;
    /*
     * 
     * 
     * % --- Executes during object creation, after setting all properties.
     */
}

/*
 * The function "Mrecarga_multiple_AveET_CreateFcn" is the implementation
 * version of the "recarga_multiple/AveET_CreateFcn" M-function from file
 * "u:\final_recarga6\recarga\recarga_multiple.m" (lines 77-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 AveET_CreateFcn(hObject, eventdata, handles)
 */
static void Mrecarga_multiple_AveET_CreateFcn(mxArray * hObject,
                                              mxArray * eventdata,
                                              mxArray * handles) {
    mexLocalFunctionTable save_local_function_table_
      = mclSetCurrentLocalFunctionTable(
          &_local_function_table_recarga_multiple);
    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"), _mxarray14_, _mxarray16_, NULL));
    /*
     * else
     */
    } else {
        /*
         * set(hObject,'BackgroundColor',get(0,'defaultUicontrolBackgroundColor'));
         */
        mclAssignAns(
          &ans,
          mlfNSet(
            0,
            mclVa(hObject, "hObject"),
            _mxarray14_,
            mlfNGet(1, _mxarray18_, _mxarray19_, NULL),
            NULL));
    /*
     * end
     */
    }
    mxDestroyArray(ans);
    mxDestroyArray(handles);
    mxDestroyArray(eventdata);
    mxDestroyArray(hObject);
    mclSetCurrentLocalFunctionTable(save_local_function_table_);
    /*
     * 
     * 
     * 
     */
}

/*
 * The function "Mrecarga_multiple_AveET_Callback" is the implementation
 * version of the "recarga_multiple/AveET_Callback" M-function from file
 * "u:\final_recarga6\recarga\recarga_multiple.m" (lines 92-103). 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_multiple_AveET_Callback(mxArray * hObject,
                                             mxArray * eventdata,
                                             mxArray * handles) {
    mexLocalFunctionTable save_local_function_table_
      = mclSetCurrentLocalFunctionTable(
          &_local_function_table_recarga_multiple);
    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 input (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_multiple_Input_CreateFcn" is the implementation
 * version of the "recarga_multiple/Input_CreateFcn" M-function from file
 * "u:\final_recarga6\recarga\recarga_multiple.m" (lines 103-118). 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_multiple_Input_CreateFcn(mxArray * hObject,
                                              mxArray * eventdata,
                                              mxArray * handles) {
    mexLocalFunctionTable save_local_function_table_
      = mclSetCurrentLocalFunctionTable(
          &_local_function_table_recarga_multiple);
    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"), _mxarray14_, _mxarray16_, NULL));
    /*
     * else
     */
    } else {
        /*
         * set(hObject,'BackgroundColor',get(0,'defaultUicontrolBackgroundColor'));
         */
        mclAssignAns(
          &ans,
          mlfNSet(
            0,
            mclVa(hObject, "hObject"),
            _mxarray14_,
            mlfNGet(1, _mxarray18_, _mxarray19_, NULL),
            NULL));
    /*
     * end
     */
    }
    mxDestroyArray(ans);
    mxDestroyArray(handles);
    mxDestroyArray(eventdata);
    mxDestroyArray(hObject);
    mclSetCurrentLocalFunctionTable(save_local_function_table_);
    /*
     * 
     * 
     * 
     */
}

/*
 * The function "Mrecarga_multiple_Input_Callback" is the implementation
 * version of the "recarga_multiple/Input_Callback" M-function from file
 * "u:\final_recarga6\recarga\recarga_multiple.m" (lines 118-130). 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_multiple_Input_Callback(mxArray * hObject,
                                             mxArray * eventdata,
                                             mxArray * handles) {
    mexLocalFunctionTable save_local_function_table_
      = mclSetCurrentLocalFunctionTable(
          &_local_function_table_recarga_multiple);
    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 input (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_multiple_Length_CreateFcn" is the implementation
 * version of the "recarga_multiple/Length_CreateFcn" M-function from file
 * "u:\final_recarga6\recarga\recarga_multiple.m" (lines 130-145). 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_multiple_Length_CreateFcn(mxArray * hObject,
                                               mxArray * eventdata,
                                               mxArray * handles) {
    mexLocalFunctionTable save_local_function_table_
      = mclSetCurrentLocalFunctionTable(
          &_local_function_table_recarga_multiple);
    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"), _mxarray14_, _mxarray16_, NULL));
    /*
     * else
     */
    } else {
        /*
         * set(hObject,'BackgroundColor',get(0,'defaultUicontrolBackgroundColor'));
         */
        mclAssignAns(
          &ans,
          mlfNSet(
            0,
            mclVa(hObject, "hObject"),
            _mxarray14_,
            mlfNGet(1, _mxarray18_, _mxarray19_, NULL),
            NULL));
    /*
     * end
     */
    }
    mxDestroyArray(ans);
    mxDestroyArray(handles);
    mxDestroyArray(eventdata);
    mxDestroyArray(hObject);
    mclSetCurrentLocalFunctionTable(save_local_function_table_);
    /*
     * 
     * 
     * 
     */
}

/*
 * The function "Mrecarga_multiple_Length_Callback" is the implementation
 * version of the "recarga_multiple/Length_Callback" M-function from file
 * "u:\final_recarga6\recarga\recarga_multiple.m" (lines 145-155). 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_multiple_Length_Callback(mxArray * hObject,
                                              mxArray * eventdata,
                                              mxArray * handles) {
    mexLocalFunctionTable save_local_function_table_
      = mclSetCurrentLocalFunctionTable(
          &_local_function_table_recarga_multiple);
    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 input (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_multiple_Output_CreateFcn" is the implementation
 * version of the "recarga_multiple/Output_CreateFcn" M-function from file
 * "u:\final_recarga6\recarga\recarga_multiple.m" (lines 155-170). 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_multiple_Output_CreateFcn(mxArray * hObject,
                                               mxArray * eventdata,
                                               mxArray * handles) {
    mexLocalFunctionTable save_local_function_table_
      = mclSetCurrentLocalFunctionTable(
          &_local_function_table_recarga_multiple);
    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"), _mxarray14_, _mxarray16_, NULL));
    /*
     * else
     */
    } else {
        /*
         * set(hObject,'BackgroundColor',get(0,'defaultUicontrolBackgroundColor'));
         */
        mclAssignAns(
          &ans,
          mlfNSet(
            0,
            mclVa(hObject, "hObject"),
            _mxarray14_,
            mlfNGet(1, _mxarray18_, _mxarray19_, NULL),
            NULL));
    /*
     * end
     */
    }
    mxDestroyArray(ans);
    mxDestroyArray(handles);
    mxDestroyArray(eventdata);
    mxDestroyArray(hObject);
    mclSetCurrentLocalFunctionTable(save_local_function_table_);
    /*
     * 
     * 
     * 
     */
}

/*
 * The function "Mrecarga_multiple_Output_Callback" is the implementation
 * version of the "recarga_multiple/Output_Callback" M-function from file
 * "u:\final_recarga6\recarga\recarga_multiple.m" (lines 170-180). 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_multiple_Output_Callback(mxArray * hObject,
                                              mxArray * eventdata,
                                              mxArray * handles) {
    mexLocalFunctionTable save_local_function_table_
      = mclSetCurrentLocalFunctionTable(
          &_local_function_table_recarga_multiple);
    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 input (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_multiple_Name_CreateFcn" is the implementation
 * version of the "recarga_multiple/Name_CreateFcn" M-function from file
 * "u:\final_recarga6\recarga\recarga_multiple.m" (lines 180-195). 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_multiple_Name_CreateFcn(mxArray * hObject,
                                             mxArray * eventdata,
                                             mxArray * handles) {
    mexLocalFunctionTable save_local_function_table_
      = mclSetCurrentLocalFunctionTable(
          &_local_function_table_recarga_multiple);
    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"), _mxarray14_, _mxarray16_, NULL));
    /*
     * else
     */
    } else {
        /*
         * set(hObject,'BackgroundColor',get(0,'defaultUicontrolBackgroundColor'));
         */
        mclAssignAns(
          &ans,
          mlfNSet(
            0,
            mclVa(hObject, "hObject"),
            _mxarray14_,
            mlfNGet(1, _mxarray18_, _mxarray19_, 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_multiple_Name_Callback" is the implementation version
 * of the "recarga_multiple/Name_Callback" M-function from file
 * "u:\final_recarga6\recarga\recarga_multiple.m" (lines 195-205). 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_multiple_Name_Callback(mxArray * hObject,
                                            mxArray * eventdata,
                                            mxArray * handles) {
    mexLocalFunctionTable save_local_function_table_
      = mclSetCurrentLocalFunctionTable(
          &_local_function_table_recarga_multiple);
    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 input (see GUIDATA)
     * 
     * 
     * % Hints: contents = get(hObject,'String') returns Input contents as cell array
     * %        contents{get(hObject,'Value')} returns selected item from Input
     * 
     * 
     */
}

/*
 * The function "Mrecarga_multiple_RGCalc_Callback" is the implementation
 * version of the "recarga_multiple/RGCalc_Callback" M-function from file
 * "u:\final_recarga6\recarga\recarga_multiple.m" (lines 205-294). 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_multiple_RGCalc_Callback(mxArray * hObject,
                                              mxArray * eventdata,
                                              mxArray * handles) {
    mexLocalFunctionTable save_local_function_table_
      = mclSetCurrentLocalFunctionTable(
          &_local_function_table_recarga_multiple);
    mxArray * filenames = NULL;
    mxArray * ans = NULL;
    mxArray * fid = NULL;
    mxArray * StayDpth = NULL;
    mxArray * tstponded = NULL;
    mxArray * maxpond = NULL;
    mxArray * Dstore = NULL;
    mxArray * Dperv = NULL;
    mxArray * Dimp = NULL;
    mxArray * Arg = NULL;
    mxArray * Rd = NULL;
    mxArray * EIA = NULL;
    mxArray * CN = NULL;
    mxArray * Urate = NULL;
    mxArray * Kcz = NULL;
    mxArray * Nsoilnumber = NULL;
    mxArray * St = NULL;
    mxArray * Srz = NULL;
    mxArray * dmin = NULL;
    mxArray * C1 = NULL;
    mxArray * C2 = NULL;
    mxArray * nprecip = NULL;
    mxArray * stime = NULL;
    mxArray * time = NULL;
    mxArray * avet = NULL;
    mxArray * rundays = NULL;
    mxArray * file = NULL;
    mxArray * e = NULL;
    mxArray * DCSumm = NULL;
    mxArray * Points = NULL;
    mxArray * FileMtrx = NULL;
    mxArray * VarMtrx = NULL;
    mxArray * runs = NULL;
    mxArray * Record = NULL;
    mxArray * Summary = NULL;
    mxArray * TribA = NULL;
    mxArray * Kst = NULL;
    mxArray * Krz = NULL;
    mxArray * Ssoilnumber = NULL;
    mxArray * Rsoilnumber = NULL;
    mxArray * varfile = NULL;
    mxArray * varpre = NULL;
    mxArray * infile = NULL;
    mxArray * filename = NULL;
    mxArray * outname = NULL;
    mxArray * outpre = NULL;
    mxArray * fileext = NULL;
    mxArray * Sd = NULL;
    mxArray * unit = NULL;
    mxArray * tctpmax = NULL;
    mxArray * inot = NULL;
    mxArray * Dudrain = NULL;
    mxArray * Devap = NULL;
    mxArray * Drunoff = NULL;
    mxArray * Drunon = NULL;
    mxArray * Dprecip = NULL;
    mxArray * Drecharge = 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 input (see GUIDATA);
     * 
     * %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
     * % ZERO INITIAL OUTPUTS
     * %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
     * Drecharge = 0; Dprecip = 0; Drunon = 0; Drunoff = 0; Devap = 0; Dudrain = 0;
     */
    mlfAssign(&Drecharge, _mxarray18_);
    mlfAssign(&Dprecip, _mxarray18_);
    mlfAssign(&Drunon, _mxarray18_);
    mlfAssign(&Drunoff, _mxarray18_);
    mlfAssign(&Devap, _mxarray18_);
    mlfAssign(&Dudrain, _mxarray18_);
    /*
     * inot = 0; tctpmax = 0;
     */
    mlfAssign(&inot, _mxarray18_);
    mlfAssign(&tctpmax, _mxarray18_);
    /*
     * unit = get(handles.Units,'Value');
     */
    mlfAssign(
      &unit,
      mlfNGet(
        1,
        mlfIndexRef(mclVa(handles, "handles"), ".Units"), _mxarray21_, NULL));
    /*
     * Sd=.35;		% depression storage in pervious area [cm]
     */
    mlfAssign(&Sd, _mxarray23_);
    /*
     * 
     * %avet= str2num(get(handles.AveET,'String'));
     * %rundays = str2num(get(handles.Length,'String'));
     * %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
     * %DATAFILE RETRIEVAL
     * %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
     * fileext = '.txt';
     */
    mlfAssign(&fileext, _mxarray24_);
    /*
     * outpre = get(handles.Output,'String');  %File to write output to
     */
    mlfAssign(
      &outpre,
      mlfNGet(
        1,
        mlfIndexRef(mclVa(handles, "handles"), ".Output"), _mxarray26_, NULL));
    /*
     * outname = strcat(outpre,fileext);
     */
    mlfAssign(
      &outname,
      mlfStrcat(mclVv(outpre, "outpre"), mclVv(fileext, "fileext"), NULL));
    /*
     * filename = get(handles.Input,'String');  %Precipitation File
     */
    mlfAssign(
      &filename,
      mlfNGet(
        1,
        mlfIndexRef(mclVa(handles, "handles"), ".Input"), _mxarray26_, NULL));
    /*
     * infile = strcat(filename,fileext);
     */
    mlfAssign(
      &infile,
      mlfStrcat(mclVv(filename, "filename"), mclVv(fileext, "fileext"), NULL));
    /*
     * varpre = get(handles.Input,'String');  %File w/ Run Variables 
     */
    mlfAssign(
      &varpre,
      mlfNGet(
        1,
        mlfIndexRef(mclVa(handles, "handles"), ".Input"), _mxarray26_, NULL));
    /*
     * varfile = strcat(varpre,fileext);
     */
    mlfAssign(
      &varfile,
      mlfStrcat(mclVv(varpre, "varpre"), mclVv(fileext, "fileext"), NULL));
    /*
     * %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
     * % Default Parameters for Multiple Runs
     * %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
     * Rsoilnumber = 2;  %Loamy Sand Root Zone
     */
    mlfAssign(&Rsoilnumber, _mxarray28_);
    /*
     * Ssoilnumber = 1;  %Sand Storage Zone
     */
    mlfAssign(&Ssoilnumber, _mxarray0_);
    /*
     * Krz = 10;         %Root Zone infiltration, incl. macropores
     */
    mlfAssign(&Krz, _mxarray29_);
    /*
     * Kst = 15;         %Storage Zone infiltration
     */
    mlfAssign(&Kst, _mxarray30_);
    /*
     * TribA = 1000;     %Default tributary area [m2]
     */
    mlfAssign(&TribA, _mxarray31_);
    /*
     * Summary = 0;      %Do not include summary file of each run
     */
    mlfAssign(&Summary, _mxarray18_);
    /*
     * Record = 0;       %Do not include record file for each run
     */
    mlfAssign(&Record, _mxarray18_);
    /*
     * %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
     * %Run Modules
     * %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
     * runs = dlmread(varfile,'\t',[0 0 0 0]); %runs in input file
     */
    mlfAssign(
      &runs,
      mlfDlmread(
        mclVv(varfile, "varfile"), _mxarray32_, _mxarray34_, NULL, NULL));
    /*
     * VarMtrx = dlmread(varfile,'\t',[2 1 runs+1 11]);  %Variable matrix for runs
     */
    mlfAssign(
      &VarMtrx,
      mlfDlmread(
        mclVv(varfile, "varfile"),
        _mxarray32_,
        mlfHorzcat(
          _mxarray28_,
          _mxarray0_,
          mclPlus(mclVv(runs, "runs"), _mxarray0_),
          _mxarray36_,
          NULL),
        NULL,
        NULL));
    /*
     * FileMtrx = textread(varfile,'%s',runs*12+24,'delimiter','\t');
     */
    mlfAssign(
      &FileMtrx,
      mlfNTextread(
        0,
        mclValueVarargout(),
        mclVv(varfile, "varfile"),
        _mxarray37_,
        mclPlus(mclMtimes(mclVv(runs, "runs"), _mxarray39_), _mxarray40_),
        _mxarray41_,
        _mxarray32_,
        NULL));
    /*
     * Points = 12;
     */
    mlfAssign(&Points, _mxarray39_);
    /*
     * DCSumm=zeros(runs,18);
     */
    mlfAssign(&DCSumm, mlfZeros(mclVv(runs, "runs"), _mxarray43_, NULL));
    /*
     * e=1;
     */
    mlfAssign(&e, _mxarray0_);
    /*
     * for e=1:runs;  %Loop for number of runs
     */
    {
        int v_ = mclForIntStart(1);
        int e_ = mclForIntEnd(mclVv(runs, "runs"));
        if (v_ > e_) {
            mlfAssign(&e, _mxarray11_);
        } else {
            /*
             * file(e,1) = FileMtrx(e*12+12,1); filename = char(file(e,1)); 
             * rundays = VarMtrx(e,1); avet = VarMtrx(e,2);
             * time=rundays*24*60;			% min in data file
             * stime=time/60;				% total time of simulation [h]
             * infile = strcat(filename,fileext);
             * nprecip=dlmread(infile,'\t',[1 0 ceil(stime)+1 2]);
             * if unit == 1
             * nprecip(:,2)=nprecip(:,2)./10;      %convert from [mm h-1] to [cm h-1]
             * nprecip(:,3)=nprecip(:,3)./10;      %convert from [mm h-1] to [cm h-1]
             * C2 = 1; C1 = 1;            %no conversion
             * else
             * nprecip(:,2)=nprecip(:,2).*2.54;      %convert from [in/hr] to [cm/hr]
             * nprecip(:,3)=nprecip(:,3).*2.54;      %convert from [in/hr] to [cm/hr]
             * C2 = 1/4046.9; C1 = 10.76;            %convert area from [m2] to [acre] and [sf]
             * end
             * 
             * dmin = VarMtrx(e,3);  Srz = VarMtrx(e,4); St = VarMtrx(e,5); Nsoilnumber = VarMtrx(e,6); Kcz = VarMtrx(e,7);
             * Urate = VarMtrx(e,8); CN = VarMtrx(e,9); EIA = VarMtrx(e,10); Rd = VarMtrx(e,11); Arg = (Rd/100)*TribA;
             * TribA = C2*1000;  %Total Tributary Area
             * Arg = (Rd/100)*1000*C1;
             * 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
             * [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
             * StayDpth=Dprecip - Drunoff - Dudrain;
             * %DCSumm(e,:)=[dmin Srz VarMtrx(e,3) Nsoilnumber Kcz VarMtrx(e,6) CN EIA*100 Arg/10 Dprecip RnOnDpth RoffDpth EvapDpth Drecharge UDpth StayDpth maxpond inot];
             * DCSumm(e,:)=[dmin Srz St Nsoilnumber Kcz Urate CN EIA Rd Dprecip Drunon Drunoff Devap Drecharge Dudrain StayDpth maxpond inot];
             * end
             */
            for (; ; ) {
                mclIntArrayAssign2(
                  &file,
                  mclArrayRef2(
                    mclVv(FileMtrx, "FileMtrx"),
                    mlfScalar(
                      svDoubleScalarPlus(
                        svDoubleScalarTimes((double) v_, 12.0), 12.0)),
                    _mxarray0_),
                  v_,
                  1);
                mlfAssign(
                  &filename,
                  mlfChar(mclIntArrayRef2(mclVv(file, "file"), v_, 1), NULL));
                mlfAssign(
                  &rundays, mclIntArrayRef2(mclVv(VarMtrx, "VarMtrx"), v_, 1));
                mlfAssign(
                  &avet, mclIntArrayRef2(mclVv(VarMtrx, "VarMtrx"), v_, 2));
                mlfAssign(
                  &time,
                  mclMtimes(
                    mclMtimes(mclVv(rundays, "rundays"), _mxarray40_),
                    _mxarray44_));
                mlfAssign(
                  &stime, mclMrdivide(mclVv(time, "time"), _mxarray44_));
                mlfAssign(
                  &infile,
                  mlfStrcat(
                    mclVv(filename, "filename"),
                    mclVv(fileext, "fileext"),
                    NULL));
                mlfAssign(
                  &nprecip,
                  mlfDlmread(
                    mclVv(infile, "infile"),
                    _mxarray32_,
                    mlfHorzcat(
                      _mxarray0_,
                      _mxarray18_,
                      mclPlus(mlfCeil(mclVv(stime, "stime")), _mxarray0_),
                      _mxarray28_,
                      NULL),
                    NULL,
                    NULL));
                if (mclEqBool(mclVv(unit, "unit"), _mxarray0_)) {
                    mclArrayAssign2(
                      &nprecip,
                      mclRdivide(
                        mclArrayRef2(
                          mclVv(nprecip, "nprecip"),
                          mlfCreateColonIndex(),
                          _mxarray28_),
                        _mxarray29_),
                      mlfCreateColonIndex(),
                      _mxarray28_);
                    mclArrayAssign2(
                      &nprecip,
                      mclRdivide(
                        mclArrayRef2(
                          mclVv(nprecip, "nprecip"),
                          mlfCreateColonIndex(),
                          _mxarray45_),
                        _mxarray29_),
                      mlfCreateColonIndex(),
                      _mxarray45_);
                    mlfAssign(&C2, _mxarray0_);
                    mlfAssign(&C1, _mxarray0_);
                } else {
                    mclArrayAssign2(
                      &nprecip,
                      mclTimes(
                        mclArrayRef2(
                          mclVv(nprecip, "nprecip"),
                          mlfCreateColonIndex(),
                          _mxarray28_),
                        _mxarray46_),
                      mlfCreateColonIndex(),
                      _mxarray28_);
                    mclArrayAssign2(
                      &nprecip,
                      mclTimes(
                        mclArrayRef2(
                          mclVv(nprecip, "nprecip"),
                          mlfCreateColonIndex(),
                          _mxarray45_),
                        _mxarray46_),
                      mlfCreateColonIndex(),
                      _mxarray45_);
                    mlfAssign(&C2, _mxarray47_);
                    mlfAssign(&C1, _mxarray48_);
                }
                mlfAssign(
                  &dmin, mclIntArrayRef2(mclVv(VarMtrx, "VarMtrx"), v_, 3));
                mlfAssign(
                  &Srz, mclIntArrayRef2(mclVv(VarMtrx, "VarMtrx"), v_, 4));
                mlfAssign(
                  &St, mclIntArrayRef2(mclVv(VarMtrx, "VarMtrx"), v_, 5));
                mlfAssign(
                  &Nsoilnumber,
                  mclIntArrayRef2(mclVv(VarMtrx, "VarMtrx"), v_, 6));
                mlfAssign(
                  &Kcz, mclIntArrayRef2(mclVv(VarMtrx, "VarMtrx"), v_, 7));
                mlfAssign(
                  &Urate, mclIntArrayRef2(mclVv(VarMtrx, "VarMtrx"), v_, 8));
                mlfAssign(
                  &CN, mclIntArrayRef2(mclVv(VarMtrx, "VarMtrx"), v_, 9));
                mlfAssign(
                  &EIA, mclIntArrayRef2(mclVv(VarMtrx, "VarMtrx"), v_, 10));
                mlfAssign(
                  &Rd, mclIntArrayRef2(mclVv(VarMtrx, "VarMtrx"), v_, 11));
                mlfAssign(
                  &Arg,
                  mclMtimes(
                    mclMrdivide(mclVv(Rd, "Rd"), _mxarray49_),
                    mclVv(TribA, "TribA")));
                mlfAssign(&TribA, mclMtimes(mclVv(C2, "C2"), _mxarray31_));
                mlfAssign(
                  &Arg,
                  mclMtimes(
                    mclMtimes(
                      mclMrdivide(mclVv(Rd, "Rd"), _mxarray49_), _mxarray31_),
                    mclVv(C1, "C1")));
                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 {
                    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")));
                }
                mlfAssign(
                  &StayDpth,
                  mclMinus(
                    mclMinus(
                      mclVv(Dprecip, "Dprecip"), mclVv(Drunoff, "Drunoff")),
                    mclVv(Dudrain, "Dudrain")));
                mclArrayAssign2(
                  &DCSumm,
                  mlfHorzcat(
                    mclVv(dmin, "dmin"),
                    mclVv(Srz, "Srz"),
                    mclVv(St, "St"),
                    mclVv(Nsoilnumber, "Nsoilnumber"),
                    mclVv(Kcz, "Kcz"),
                    mclVv(Urate, "Urate"),
                    mclVv(CN, "CN"),
                    mclVv(EIA, "EIA"),
                    mclVv(Rd, "Rd"),
                    mclVv(Dprecip, "Dprecip"),
                    mclVv(Drunon, "Drunon"),
                    mclVv(Drunoff, "Drunoff"),
                    mclVv(Devap, "Devap"),
                    mclVv(Drecharge, "Drecharge"),
                    mclVv(Dudrain, "Dudrain"),
                    mclVv(StayDpth, "StayDpth"),
                    mclVv(maxpond, "maxpond"),
                    mclVv(inot, "inot"),
                    NULL),
                  mlfScalar(v_),
                  mlfCreateColonIndex());
                if (v_ == e_) {
                    break;
                }
                ++v_;
            }
            mlfAssign(&e, mlfScalar(v_));
        }
    }
    /*
     * %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
     * %  Output Results to File                                             %
     * %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
     * fid=fopen(outname,'w'); fclose(fid);	% delete previous version & open
     */
    mlfAssign(
      &fid, mlfFopen(NULL, NULL, mclVv(outname, "outname"), _mxarray50_, NULL));
    mclAssignAns(&ans, mlfFclose(mclVv(fid, "fid")));
    /*
     * fid=fopen(outname,'at');
     */
    mlfAssign(
      &fid, mlfFopen(NULL, NULL, mclVv(outname, "outname"), _mxarray52_, NULL));
    /*
     * fprintf(fid,'Sd\t Sr\t St\t Texture\t Kn\t Ku\t CN\t EIA\t Rd\t Precip\t Runon\t Runoff\t Evap\t Recharge\t Drain\t Stayon\t maxpond(hr)\t Overflows\n');
     */
    mclAssignAns(&ans, mlfNFprintf(0, mclVv(fid, "fid"), _mxarray54_, NULL));
    /*
     * fprintf(fid,'%6.3f\t %6.3f\t %6.3f\t %6.3f\t %6.3f\t %6.3f\t %6.3f\t %6.3f\t %6.3f\t %6.3f\t %6.3f\t %6.3f\t %6.3f\t %6.3f\t %6.3f\t %6.3f\t %6.3f\t %6.0f\n',DCSumm');
     */
    mclAssignAns(
      &ans,
      mlfNFprintf(
        0,
        mclVv(fid, "fid"),
        _mxarray56_,
        mlfCtranspose(mclVv(DCSumm, "DCSumm")),
        NULL));
    /*
     * fprintf(fid,'\nFiles\n');
     */
    mclAssignAns(&ans, mlfNFprintf(0, mclVv(fid, "fid"), _mxarray58_, NULL));
    /*
     * filenames= char(file);
     */
    mlfAssign(&filenames, mlfChar(mclVv(file, "file"), NULL));
    /*
     * fprintf(fid,'%10s \n',filenames');
     */
    mclAssignAns(
      &ans,
      mlfNFprintf(
        0,
        mclVv(fid, "fid"),
        _mxarray60_,
        mlfCtranspose(mclVv(filenames, "filenames")),
        NULL));
    /*
     * fclose(fid);
     */
    mclAssignAns(&ans, mlfFclose(mclVv(fid, "fid")));
    mxDestroyArray(Drecharge);
    mxDestroyArray(Dprecip);
    mxDestroyArray(Drunon);
    mxDestroyArray(Drunoff);
    mxDestroyArray(Devap);
    mxDestroyArray(Dudrain);
    mxDestroyArray(inot);
    mxDestroyArray(tctpmax);
    mxDestroyArray(unit);
    mxDestroyArray(Sd);
    mxDestroyArray(fileext);
    mxDestroyArray(outpre);
    mxDestroyArray(outname);
    mxDestroyArray(filename);
    mxDestroyArray(infile);
    mxDestroyArray(varpre);
    mxDestroyArray(varfile);
    mxDestroyArray(Rsoilnumber);
    mxDestroyArray(Ssoilnumber);
    mxDestroyArray(Krz);
    mxDestroyArray(Kst);
    mxDestroyArray(TribA);
    mxDestroyArray(Summary);
    mxDestroyArray(Record);
    mxDestroyArray(runs);
    mxDestroyArray(VarMtrx);
    mxDestroyArray(FileMtrx);
    mxDestroyArray(Points);
    mxDestroyArray(DCSumm);
    mxDestroyArray(e);
    mxDestroyArray(file);
    mxDestroyArray(rundays);
    mxDestroyArray(avet);
    mxDestroyArray(time);
    mxDestroyArray(stime);
    mxDestroyArray(nprecip);
    mxDestroyArray(C2);
    mxDestroyArray(C1);
    mxDestroyArray(dmin);
    mxDestroyArray(Srz);
    mxDestroyArray(St);
    mxDestroyArray(Nsoilnumber);
    mxDestroyArray(Kcz);
    mxDestroyArray(Urate);
    mxDestroyArray(CN);
    mxDestroyArray(EIA);
    mxDestroyArray(Rd);
    mxDestroyArray(Arg);
    mxDestroyArray(Dimp);
    mxDestroyArray(Dperv);
    mxDestroyArray(Dstore);
    mxDestroyArray(maxpond);
    mxDestroyArray(tstponded);
    mxDestroyArray(StayDpth);
    mxDestroyArray(fid);
    mxDestroyArray(ans);
    mxDestroyArray(filenames);
    mxDestroyArray(handles);
    mxDestroyArray(eventdata);
    mxDestroyArray(hObject);
    mclSetCurrentLocalFunctionTable(save_local_function_table_);
    /*
     * 
     * %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
     * 
     * % --- Executes during object creation, after setting all properties.
     */
}

/*
 * The function "Mrecarga_multiple_Process_CreateFcn" is the implementation
 * version of the "recarga_multiple/Process_CreateFcn" M-function from file
 * "u:\final_recarga6\recarga\recarga_multiple.m" (lines 294-308). 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_multiple_Process_CreateFcn(mxArray * hObject,
                                                mxArray * eventdata,
                                                mxArray * handles) {
    mexLocalFunctionTable save_local_function_table_
      = mclSetCurrentLocalFunctionTable(
          &_local_function_table_recarga_multiple);
    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"), _mxarray14_, _mxarray16_, NULL));
    /*
     * else
     */
    } else {
        /*
         * set(hObject,'BackgroundColor',get(0,'defaultUicontrolBackgroundColor'));
         */
        mclAssignAns(
          &ans,
          mlfNSet(
            0,
            mclVa(hObject, "hObject"),
            _mxarray14_,
            mlfNGet(1, _mxarray18_, _mxarray19_, NULL),
            NULL));
    /*
     * end
     */
    }
    mxDestroyArray(ans);
    mxDestroyArray(handles);
    mxDestroyArray(eventdata);
    mxDestroyArray(hObject);
    mclSetCurrentLocalFunctionTable(save_local_function_table_);
    /*
     * 
     * % --- Executes during object creation, after setting all properties.
     */
}

/*
 * The function "Mrecarga_multiple_Data_CreateFcn" is the implementation
 * version of the "recarga_multiple/Data_CreateFcn" M-function from file
 * "u:\final_recarga6\recarga\recarga_multiple.m" (lines 308-323). 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 Data_CreateFcn(hObject, eventdata, handles)
 */
static void Mrecarga_multiple_Data_CreateFcn(mxArray * hObject,
                                             mxArray * eventdata,
                                             mxArray * handles) {
    mexLocalFunctionTable save_local_function_table_
      = mclSetCurrentLocalFunctionTable(
          &_local_function_table_recarga_multiple);
    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"), _mxarray14_, _mxarray16_, NULL));
    /*
     * else
     */
    } else {
        /*
         * set(hObject,'BackgroundColor',get(0,'defaultUicontrolBackgroundColor'));
         */
        mclAssignAns(
          &ans,
          mlfNSet(
            0,
            mclVa(hObject, "hObject"),
            _mxarray14_,
            mlfNGet(1, _mxarray18_, _mxarray19_, NULL),
            NULL));
    /*
     * end
     */
    }
    mxDestroyArray(ans);
    mxDestroyArray(handles);
    mxDestroyArray(eventdata);
    mxDestroyArray(hObject);
    mclSetCurrentLocalFunctionTable(save_local_function_table_);
    /*
     * 
     * 
     * 
     */
}

/*
 * The function "Mrecarga_multiple_Data_Callback" is the implementation version
 * of the "recarga_multiple/Data_Callback" M-function from file
 * "u:\final_recarga6\recarga\recarga_multiple.m" (lines 323-333). 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 Data_Callback(hObject, eventdata, handles)
 */
static void Mrecarga_multiple_Data_Callback(mxArray * hObject,
                                            mxArray * eventdata,
                                            mxArray * handles) {
    mexLocalFunctionTable save_local_function_table_
      = mclSetCurrentLocalFunctionTable(
          &_local_function_table_recarga_multiple);
    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 input (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_multiple_Units_CreateFcn" is the implementation
 * version of the "recarga_multiple/Units_CreateFcn" M-function from file
 * "u:\final_recarga6\recarga\recarga_multiple.m" (lines 333-348). 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_multiple_Units_CreateFcn(mxArray * hObject,
                                              mxArray * eventdata,
                                              mxArray * handles) {
    mexLocalFunctionTable save_local_function_table_
      = mclSetCurrentLocalFunctionTable(
          &_local_function_table_recarga_multiple);
    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: 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"), _mxarray14_, _mxarray16_, NULL));
    /*
     * else
     */
    } else {
        /*
         * set(hObject,'BackgroundColor',get(0,'defaultUicontrolBackgroundColor'));
         */
        mclAssignAns(
          &ans,
          mlfNSet(
            0,
            mclVa(hObject, "hObject"),
            _mxarray14_,
            mlfNGet(1, _mxarray18_, _mxarray19_, NULL),
            NULL));
    /*
     * end
     */
    }
    mxDestroyArray(ans);
    mxDestroyArray(handles);
    mxDestroyArray(eventdata);
    mxDestroyArray(hObject);
    mclSetCurrentLocalFunctionTable(save_local_function_table_);
    /*
     * 
     * 
     * % --- Executes on selection change in Units.
     */
}

/*
 * The function "Mrecarga_multiple_Units_Callback" is the implementation
 * version of the "recarga_multiple/Units_Callback" M-function from file
 * "u:\final_recarga6\recarga\recarga_multiple.m" (lines 348-357). 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_multiple_Units_Callback(mxArray * hObject,
                                             mxArray * eventdata,
                                             mxArray * handles) {
    mexLocalFunctionTable save_local_function_table_
      = mclSetCurrentLocalFunctionTable(
          &_local_function_table_recarga_multiple);
    mclCopyArray(&hObject);
    mclCopyArray(&eventdata);
    mclCopyArray(&handles);
    mxDestroyArray(handles);
    mxDestroyArray(eventdata);
    mxDestroyArray(hObject);
    mclSetCurrentLocalFunctionTable(save_local_function_table_);
    /*
     * % hObject    handle to Units (see GCBO)
     * % eventdata  reserved - to be defined in a future version of MATLAB
     * % handles    structure with handles and user input (see GUIDATA)
     * 
     * % Hints: contents = get(hObject,'String') returns Units contents as cell array
     * %        contents{get(hObject,'Value')} returns selected item from Units
     * 
     * 
     */
}
