//
// MATLAB Compiler: 2.2
// Date: Wed Mar 10 16:44:47 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" "-p" "-W" "main" "-L"
// "Cpp" "-t" "-T" "link:exe" "-h" "libmmfile.mlib" "-B" "sglcpp" "-p" "-W"
// "main" "-L" "Cpp" "-t" "-T" "link:exe" "-h" "libmmfile.mlib" "-W" "mainhg"
// "libmwsglm.mlib" "hier_community.m" "Default.m" "Stop_Simulation.m"
// "Call_SaveLoad_Fig.m" "SaveLoad_Fig.m" "SaveLoad.m" "Load_Population_Data.m"
// "Save_Population_Data.m" "Start_hier_community.m" "MyInline.m" "My_Eval.m"
// "isnumber.m" "Find_Var.m" "Change_Number_of_Populations.m"
// "Switch_Populations.m" "Store_Parameters.m" 
//
#include "SaveLoad.hpp"
#include "Load_Population_Data.hpp"
#include "Save_Population_Data.hpp"
#include "libmatlbm.hpp"
#include "libmmfile.hpp"
#include "libmwsglm.hpp"

static mxChar _array1_[134] = { 'R', 'u', 'n', '-', 't', 'i', 'm', 'e', ' ',
                                'E', 'r', 'r', 'o', 'r', ':', ' ', 'F', 'i',
                                'l', 'e', ':', ' ', 'S', 'a', 'v', 'e', 'L',
                                'o', 'a', 'd', ' ', 'L', 'i', 'n', 'e', ':',
                                ' ', '1', ' ', 'C', 'o', 'l', 'u', 'm', 'n',
                                ':', ' ', '1', ' ', 'T', 'h', 'e', ' ', 'f',
                                'u', 'n', 'c', 't', 'i', 'o', 'n', ' ', '"',
                                'S', 'a', 'v', 'e', 'L', 'o', 'a', 'd', '"',
                                ' ', 'w', 'a', 's', ' ', 'c', 'a', 'l', 'l',
                                'e', 'd', ' ', 'w', 'i', 't', 'h', ' ', 'm',
                                'o', 'r', 'e', ' ', 't', 'h', 'a', 'n', ' ',
                                't', 'h', 'e', ' ', 'd', 'e', 'c', 'l', 'a',
                                'r', 'e', 'd', ' ', 'n', 'u', 'm', 'b', 'e',
                                'r', ' ', 'o', 'f', ' ', 'o', 'u', 't', 'p',
                                'u', 't', 's', ' ', '(', '0', ')', '.' };
static mwArray _mxarray0_ = mclInitializeString(134, _array1_);

static mxChar _array3_[168] = { 'R', 'u', 'n', '-', 't', 'i', 'm', 'e', ' ',
                                'E', 'r', 'r', 'o', 'r', ':', ' ', 'F', 'i',
                                'l', 'e', ':', ' ', 'S', 'a', 'v', 'e', 'L',
                                'o', 'a', 'd', '/', 'C', 'o', 'n', 'v', 'e',
                                'r', 't', 'T', 'o', 'S', 't', 'r', 'i', 'n',
                                'g', ' ', 'L', 'i', 'n', 'e', ':', ' ', '1',
                                '1', '9', ' ', 'C', 'o', 'l', 'u', 'm', 'n',
                                ':', ' ', '1', ' ', 'T', 'h', 'e', ' ', 'f',
                                'u', 'n', 'c', 't', 'i', 'o', 'n', ' ', '"',
                                'S', 'a', 'v', 'e', 'L', 'o', 'a', 'd', '/',
                                'C', 'o', 'n', 'v', 'e', 'r', 't', 'T', 'o',
                                'S', 't', 'r', 'i', 'n', 'g', '"', ' ', 'w',
                                'a', 's', ' ', 'c', 'a', 'l', 'l', 'e', 'd',
                                ' ', 'w', 'i', 't', 'h', ' ', 'm', 'o', 'r',
                                'e', ' ', 't', 'h', 'a', 'n', ' ', 't', 'h',
                                'e', ' ', 'd', 'e', 'c', 'l', 'a', 'r', 'e',
                                'd', ' ', 'n', 'u', 'm', 'b', 'e', 'r', ' ',
                                'o', 'f', ' ', 'o', 'u', 't', 'p', 'u', 't',
                                's', ' ', '(', '1', ')', '.' };
static mwArray _mxarray2_ = mclInitializeString(168, _array3_);

static mxChar _array5_[167] = { 'R', 'u', 'n', '-', 't', 'i', 'm', 'e', ' ',
                                'E', 'r', 'r', 'o', 'r', ':', ' ', 'F', 'i',
                                'l', 'e', ':', ' ', 'S', 'a', 'v', 'e', 'L',
                                'o', 'a', 'd', '/', 'C', 'o', 'n', 'v', 'e',
                                'r', 't', 'T', 'o', 'S', 't', 'r', 'i', 'n',
                                'g', ' ', 'L', 'i', 'n', 'e', ':', ' ', '1',
                                '1', '9', ' ', 'C', 'o', 'l', 'u', 'm', 'n',
                                ':', ' ', '1', ' ', 'T', 'h', 'e', ' ', 'f',
                                'u', 'n', 'c', 't', 'i', 'o', 'n', ' ', '"',
                                'S', 'a', 'v', 'e', 'L', 'o', 'a', 'd', '/',
                                'C', 'o', 'n', 'v', 'e', 'r', 't', 'T', 'o',
                                'S', 't', 'r', 'i', 'n', 'g', '"', ' ', 'w',
                                'a', 's', ' ', 'c', 'a', 'l', 'l', 'e', 'd',
                                ' ', 'w', 'i', 't', 'h', ' ', 'm', 'o', 'r',
                                'e', ' ', 't', 'h', 'a', 'n', ' ', 't', 'h',
                                'e', ' ', 'd', 'e', 'c', 'l', 'a', 'r', 'e',
                                'd', ' ', 'n', 'u', 'm', 'b', 'e', 'r', ' ',
                                'o', 'f', ' ', 'i', 'n', 'p', 'u', 't', 's',
                                ' ', '(', '1', ')', '.' };
static mwArray _mxarray4_ = mclInitializeString(167, _array5_);
static mwArray _mxarray6_ = mclInitializeDoubleVector(0, 0, (double *)NULL);
static mwArray _mxarray7_ = mclInitializeDouble(1.0);
static mwArray _mxarray8_ = mclInitializeDouble(2.0);
static mwArray _mxarray9_ = mclInitializeDouble(3.0);

static mxChar _array11_[1] = { ':' };
static mwArray _mxarray10_ = mclInitializeString(1, _array11_);

static mxChar _array13_[1] = { 0x005c };
static mwArray _mxarray12_ = mclInitializeString(1, _array13_);

static mxChar _array15_[3] = { 'T', 'a', 'g' };
static mwArray _mxarray14_ = mclInitializeString(3, _array15_);

static mxChar _array17_[12] = { 'F', 'i', 'g', '_', 's', 'a',
                                'v', 'e', 'l', 'o', 'a', 'd' };
static mwArray _mxarray16_ = mclInitializeString(12, _array17_);

static mxChar _array19_[13] = { 'L', 'i', 's', 't', 'b', 'o', 'x',
                                '_', 'f', 'i', 'l', 'e', 's' };
static mwArray _mxarray18_ = mclInitializeString(13, _array19_);

static mxChar _array21_[19] = { 'P', 'o', 'p', 'u', 'p', 'M', 'e',
                                'n', 'u', '_', 'd', 'i', 'r', 'e',
                                'c', 't', 'o', 'r', 'y' };
static mwArray _mxarray20_ = mclInitializeString(19, _array21_);

static mxChar _array23_[13] = { 'E', 'd', 'i', 't', 'T', 'e', 'x',
                                't', '_', 'f', 'i', 'l', 'e' };
static mwArray _mxarray22_ = mclInitializeString(13, _array23_);

static mxChar _array25_[15] = { 'E', 'd', 'i', 't', 'T', 'e', 'x', 't',
                                '_', 'c', 'u', 'r', 'd', 'i', 'r' };
static mwArray _mxarray24_ = mclInitializeString(15, _array25_);

static mxChar _array27_[16] = { 'S', 't', 'a', 't', 'i', 'c', 'T', 'e',
                                'x', 't', '_', 't', 'i', 't', 'l', 'e' };
static mwArray _mxarray26_ = mclInitializeString(16, _array27_);

static mxChar _array29_[12] = { 'D', 'I', 'S', 'P', 'L', 'A',
                                'Y', '_', 'F', 'I', 'L', 'E' };
static mwArray _mxarray28_ = mclInitializeString(12, _array29_);

static mxChar _array31_[6] = { 'S', 't', 'r', 'i', 'n', 'g' };
static mwArray _mxarray30_ = mclInitializeString(6, _array31_);

static mxChar _array33_[5] = { 'V', 'a', 'l', 'u', 'e' };
static mwArray _mxarray32_ = mclInitializeString(5, _array33_);

static mxChar _array35_[10] = { 'I', 'N', 'I', 'T', 'I',
                                'A', 'L', 'I', 'Z', 'E' };
static mwArray _mxarray34_ = mclInitializeString(10, _array35_);

static mxChar _array37_[8] = { 'U', 's', 'e', 'r', 'D', 'a', 't', 'a' };
static mwArray _mxarray36_ = mclInitializeString(8, _array37_);

static mxChar _array39_[4] = { 'S', 'A', 'V', 'E' };
static mwArray _mxarray38_ = mclInitializeString(4, _array39_);

static mxChar _array41_[11] = { 'S', 'A', 'V', 'I', 'N', 'G',
                                ' ', 'D', 'A', 'T', 'A' };
static mwArray _mxarray40_ = mclInitializeString(11, _array41_);

static mxChar _array43_[4] = { 'L', 'O', 'A', 'D' };
static mwArray _mxarray42_ = mclInitializeString(4, _array43_);

static mxChar _array45_[12] = { 'L', 'O', 'A', 'D', 'I', 'N',
                                'G', ' ', 'D', 'A', 'T', 'A' };
static mwArray _mxarray44_ = mclInitializeString(12, _array45_);

static mxChar _array47_[9] = { 'C', 'H', 'A', 'N', 'G', 'E', 'D', 'I', 'R' };
static mwArray _mxarray46_ = mclInitializeString(9, _array47_);
static mwArray _mxarray48_ = mclInitializeCharVector(0, 0, (mxChar *)NULL);

static mxChar _array50_[2] = { '*', '.' };
static mwArray _mxarray49_ = mclInitializeString(2, _array50_);

static mxChar _array52_[5] = { '*', '.', 'm', 'a', 't' };
static mwArray _mxarray51_ = mclInitializeString(5, _array52_);

static mxChar _array54_[3] = { 0x005c, '*', '.' };
static mwArray _mxarray53_ = mclInitializeString(3, _array54_);

static mxChar _array56_[6] = { 0x005c, '*', '.', 'm', 'a', 't' };
static mwArray _mxarray55_ = mclInitializeString(6, _array56_);

static mxChar _array58_[15] = { 'M', 'A', 'N', 'U', 'A', 'L', 'C', 'H',
                                'A', 'N', 'G', 'E', 'D', 'I', 'R' };
static mwArray _mxarray57_ = mclInitializeString(15, _array58_);

static mxChar _array60_[3] = { 'd', 'i', 'r' };
static mwArray _mxarray59_ = mclInitializeString(3, _array60_);

static mxChar _array62_[4] = { 'F', 'I', 'L', 'E' };
static mwArray _mxarray61_ = mclInitializeString(4, _array62_);

static mxChar _array64_[2] = { 'O', 'K' };
static mwArray _mxarray63_ = mclInitializeString(2, _array64_);
static mwArray _mxarray65_ = mclInitializeDouble(0.0);
static mwArray _mxarray66_ = mclInitializeCellVector(0, 0, (mxArray * *)NULL);

static mxChar _array68_[4] = { 'n', 'a', 'm', 'e' };
static mwArray _mxarray67_ = mclInitializeString(4, _array68_);

void InitializeModule_SaveLoad() {
}

void TerminateModule_SaveLoad() {
}

static mwArray SaveLoad_ConvertToString(mwArray field = mwArray::DIN);
#ifdef __cplusplus
extern "C"
#endif
void mlxSaveLoad_ConvertToString(int nlhs,
                                 mxArray * plhs[],
                                 int nrhs,
                                 mxArray * prhs[]);
static void MSaveLoad(mwArray varargin);
static mwArray MSaveLoad_ConvertToString(int nargout_, mwArray field);

static mexFunctionTableEntry local_function_table_[1]
  = { { "ConvertToString", mlxSaveLoad_ConvertToString, 1, 1, NULL } };

_mexLocalFunctionTable _local_function_table_SaveLoad
  = { 1, local_function_table_ };

//
// The function "SaveLoad" contains the normal interface for the "SaveLoad"
// M-function from file "C:\shu\hier_community_exe\SaveLoad.m" (lines 1-119).
// This function processes any input arguments and passes them to the
// implementation version of the function, appearing above.
//
void SaveLoad(mwVarargin varargin) {
    MSaveLoad(varargin.ToArray());
}

//
// The function "mlxSaveLoad" contains the feval interface for the "SaveLoad"
// M-function from file "C:\shu\hier_community_exe\SaveLoad.m" (lines 1-119).
// The feval function calls the implementation version of SaveLoad through this
// function. This function processes any input arguments and passes them to the
// implementation version of the function, appearing above.
//
void mlxSaveLoad(int nlhs, mxArray * plhs[], int nrhs, mxArray * prhs[]) {
    MW_BEGIN_MLX();
    {
        mwArray mprhs[1];
        if (nlhs > 0) {
            error(_mxarray0_);
        }
        mprhs[0] = mclCreateVararginCell(nrhs, prhs);
        MSaveLoad(mprhs[0]);
    }
    MW_END_MLX();
}

//
// The function "SaveLoad_ConvertToString" contains the normal interface for
// the "SaveLoad/ConvertToString" M-function from file
// "C:\shu\hier_community_exe\SaveLoad.m" (lines 119-128). This function
// processes any input arguments and passes them to the implementation version
// of the function, appearing above.
//
static mwArray SaveLoad_ConvertToString(mwArray field) {
    int nargout(1);
    mwArray str(mclGetUninitializedArray());
    str = MSaveLoad_ConvertToString(nargout, field);
    return str;
}

//
// The function "mlxSaveLoad_ConvertToString" contains the feval interface for
// the "SaveLoad/ConvertToString" M-function from file
// "C:\shu\hier_community_exe\SaveLoad.m" (lines 119-128). The feval function
// calls the implementation version of SaveLoad/ConvertToString through this
// function. This function processes any input arguments and passes them to the
// implementation version of the function, appearing above.
//
void mlxSaveLoad_ConvertToString(int nlhs,
                                 mxArray * plhs[],
                                 int nrhs,
                                 mxArray * prhs[]) {
    MW_BEGIN_MLX();
    {
        mwArray mprhs[1];
        mwArray mplhs[1];
        int i;
        mclCppUninitializeArrays(1, mplhs);
        if (nlhs > 1) {
            error(_mxarray2_);
        }
        if (nrhs > 1) {
            error(_mxarray4_);
        }
        for (i = 0; i < 1 && i < nrhs; ++i) {
            mprhs[i] = mwArray(prhs[i], 0);
        }
        for (; i < 1; ++i) {
            mprhs[i].MakeDIN();
        }
        mplhs[0] = MSaveLoad_ConvertToString(nlhs, mprhs[0]);
        plhs[0] = mplhs[0].FreezeData();
    }
    MW_END_MLX();
}

//
// The function "MSaveLoad" is the implementation version of the "SaveLoad"
// M-function from file "C:\shu\hier_community_exe\SaveLoad.m" (lines 1-119).
// 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 SaveLoad(varargin)
//
static void MSaveLoad(mwArray varargin) {
    mwLocalFunctionTable save_local_function_table_
      (&_local_function_table_SaveLoad);
    int nargin_(nargin(-1, mwVarargin(varargin)));
    mwArray file(mclGetUninitializedArray());
    mwArray msg(mclGetUninitializedArray());
    mwArray curdir(mclGetUninitializedArray());
    mwArray datadir(mclGetUninitializedArray());
    mwArray directories(mclGetUninitializedArray());
    mwArray ans(mclGetUninitializedArray());
    mwArray pos(mclGetUninitializedArray());
    mwArray files(mclGetUninitializedArray());
    mwArray title_handle(mclGetUninitializedArray());
    mwArray curdir_handle(mclGetUninitializedArray());
    mwArray file_handle(mclGetUninitializedArray());
    mwArray directory_handle(mclGetUninitializedArray());
    mwArray files_handle(mclGetUninitializedArray());
    mwArray saveload_handle(mclGetUninitializedArray());
    mwArray type(mclGetUninitializedArray());
    mwArray action(mclGetUninitializedArray());
    mwArray name(mclGetUninitializedArray());
    //
    // 
    // name=[];
    //
    name = _mxarray6_;
    //
    // if(nargin==1)
    //
    if (nargin_ == 1) {
        //
        // action=varargin{1};
        //
        action = mwVsa(varargin, "varargin").cell(_mxarray7_);
    //
    // elseif(nargin==2);
    //
    } else if (nargin_ == 2) {
        //
        // name=varargin{1};
        //
        name = mwVsa(varargin, "varargin").cell(_mxarray7_);
        //
        // action=varargin{2};
        //
        action = mwVsa(varargin, "varargin").cell(_mxarray8_);
    //
    // elseif(nargin==3)
    //
    } else if (nargin_ == 3) {
        //
        // name=varargin{1};
        //
        name = mwVsa(varargin, "varargin").cell(_mxarray7_);
        //
        // action=varargin{2};
        //
        action = mwVsa(varargin, "varargin").cell(_mxarray8_);
        //
        // type=varargin{3};
        //
        type = mwVsa(varargin, "varargin").cell(_mxarray9_);
    //
    // end
    //
    }
    //
    // 
    // if(~isempty(name))
    //
    if (mclNotBool(mwVe(isempty(mwVv(name, "name"))))) {
        //
        // if(length(name)==2 & isletter(name(1)) & name(2)==':')
        //
        mwArray a_(mclLengthInt(mwVv(name, "name")) == 2);
        if (tobool(a_)) {
            a_
              = a_
                & mwVe(
                    isletter(mwVe(mclIntArrayRef(mwVsv(name, "name"), 1))));
        } else {
            a_ = 0;
        }
        if (tobool(a_)
            && tobool(
                 a_
                 & mwVe(mclIntArrayRef(mwVsv(name, "name"), 2))
                   == _mxarray10_)) {
            //
            // name(end+1)='\';
            //
            mclArrayAssign(
              &name,
              _mxarray12_,
              end(mwVv(name, "name"), _mxarray7_, _mxarray7_) + _mxarray7_);
        } else {
        }
    //
    // end
    // end
    //
    }
    //
    // 
    // saveload_handle=findobj('Tag','Fig_saveload');
    //
    saveload_handle = findobj(mwVarargin(_mxarray14_, _mxarray16_));
    //
    // files_handle=findobj(saveload_handle,'Tag','Listbox_files');
    //
    files_handle
      = findobj(
          mwVarargin(
            mwVv(saveload_handle, "saveload_handle"),
            _mxarray14_,
            _mxarray18_));
    //
    // directory_handle=findobj(saveload_handle,'Tag','PopupMenu_directory');
    //
    directory_handle
      = findobj(
          mwVarargin(
            mwVv(saveload_handle, "saveload_handle"),
            _mxarray14_,
            _mxarray20_));
    //
    // file_handle=findobj(saveload_handle,'Tag','EditText_file');
    //
    file_handle
      = findobj(
          mwVarargin(
            mwVv(saveload_handle, "saveload_handle"),
            _mxarray14_,
            _mxarray22_));
    //
    // curdir_handle=findobj(saveload_handle,'Tag','EditText_curdir');
    //
    curdir_handle
      = findobj(
          mwVarargin(
            mwVv(saveload_handle, "saveload_handle"),
            _mxarray14_,
            _mxarray24_));
    //
    // title_handle=findobj(saveload_handle,'Tag','StaticText_title');
    //
    title_handle
      = findobj(
          mwVarargin(
            mwVv(saveload_handle, "saveload_handle"),
            _mxarray14_,
            _mxarray26_));
    //
    // 
    // switch action
    //
    {
        mwArray v_(mwVv(action, "action"));
        if (switchcompare(v_, _mxarray28_)) {
            //
            // 
            // case 'DISPLAY_FILE'
            // files=get(files_handle,'String');
            //
            files
              = Nget(
                  1,
                  mwVarargin(mwVv(files_handle, "files_handle"), _mxarray30_));
            //
            // pos=get(files_handle,'Value');
            //
            pos
              = Nget(
                  1,
                  mwVarargin(mwVv(files_handle, "files_handle"), _mxarray32_));
            //
            // set(file_handle,'String',files{pos});
            //
            ans.EqAns(
              Nset(
                0,
                mwVarargin(
                  mwVv(file_handle, "file_handle"),
                  _mxarray30_,
                  mwVe(mwVsv(files, "files").cell(mwVsv(pos, "pos"))))));
        //
        // 
        // case 'INITIALIZE'
        //
        } else if (switchcompare(v_, _mxarray34_)) {
            //
            // set(gcf,'UserData',{name,name});
            //
            ans.EqAns(
              Nset(
                0,
                mwVarargin(
                  mwVe(gcf()),
                  _mxarray36_,
                  cellhcat(
                    mwVarargin(mwVv(name, "name"), mwVv(name, "name"))))));
            //
            // if(strcmp(type,'SAVE'))
            //
            if (tobool(mwVe(strcmp(mwVv(type, "type"), _mxarray38_)))) {
                //
                // set(title_handle,'String','SAVING DATA');
                //
                ans.EqAns(
                  Nset(
                    0,
                    mwVarargin(
                      mwVv(title_handle, "title_handle"),
                      _mxarray30_,
                      _mxarray40_)));
            //
            // elseif(strcmp(type,'LOAD'))
            //
            } else if (tobool(mwVe(strcmp(mwVv(type, "type"), _mxarray42_)))) {
                //
                // set(title_handle,'String','LOADING DATA');
                //
                ans.EqAns(
                  Nset(
                    0,
                    mwVarargin(
                      mwVv(title_handle, "title_handle"),
                      _mxarray30_,
                      _mxarray44_)));
            //
            // end
            //
            }
        //
        // 
        // case 'CHANGEDIR'
        //
        } else if (switchcompare(v_, _mxarray46_)) {
            //
            // directories = get(directory_handle,'String');
            //
            directories
              = Nget(
                  1,
                  mwVarargin(
                    mwVv(directory_handle, "directory_handle"), _mxarray30_));
            //
            // name = directories{get(directory_handle,'Value')};
            //
            name
              = mwVsv(directories, "directories").cell(
                  Nget(
                    1,
                    mwVarargin(
                      mwVv(directory_handle, "directory_handle"),
                      _mxarray32_)));
            //
            // set(file_handle,'String','');
            //
            ans.EqAns(
              Nset(
                0,
                mwVarargin(
                  mwVv(file_handle, "file_handle"), _mxarray30_, _mxarray48_)));
            //
            // datadir=get(saveload_handle,'UserData');
            //
            datadir
              = Nget(
                  1,
                  mwVarargin(
                    mwVv(saveload_handle, "saveload_handle"), _mxarray36_));
            //
            // cd([datadir{1},'\',name]);
            //
            ans.EqAns(
              Ncd(
                0,
                horzcat(
                  mwVarargin(
                    mwVe(mwVsv(datadir, "datadir").cell(_mxarray7_)),
                    _mxarray12_,
                    mwVv(name, "name")))));
            //
            // curdir=cd;
            //
            curdir = Ncd(1, mwArray::DIN);
            //
            // if(curdir(end)=='\')
            //
            if (mclEqBool(
                  mwVe(
                    mclArrayRef(
                      mwVsv(curdir, "curdir"),
                      end(mwVv(curdir, "curdir"), _mxarray7_, _mxarray7_))),
                  _mxarray12_)) {
                //
                // datadir{1}=curdir(1:end-1);
                //
                datadir.cell(_mxarray7_)
                = mclArrayRef(
                    mwVsv(curdir, "curdir"),
                    colon(
                      _mxarray7_,
                      end(mwVv(curdir, "curdir"), _mxarray7_, _mxarray7_)
                      - _mxarray7_));
                //
                // directories=ConvertToString(dir([curdir,'*.']));
                //
                directories
                  = SaveLoad_ConvertToString(
                      mwVe(
                        Ndir(
                          1,
                          horzcat(
                            mwVarargin(
                              mwVv(curdir, "curdir"), _mxarray49_)))));
                //
                // files=ConvertToString(dir([curdir,'*.mat']));
                //
                files
                  = SaveLoad_ConvertToString(
                      mwVe(
                        Ndir(
                          1,
                          horzcat(
                            mwVarargin(
                              mwVv(curdir, "curdir"), _mxarray51_)))));
            //
            // else
            //
            } else {
                //
                // datadir{1}=curdir;
                //
                datadir.cell(_mxarray7_) = mwVsv(curdir, "curdir");
                //
                // directories=ConvertToString(dir([curdir,'\*.']));
                //
                directories
                  = SaveLoad_ConvertToString(
                      mwVe(
                        Ndir(
                          1,
                          horzcat(
                            mwVarargin(
                              mwVv(curdir, "curdir"), _mxarray53_)))));
                //
                // files=ConvertToString(dir([curdir,'\*.mat']));
                //
                files
                  = SaveLoad_ConvertToString(
                      mwVe(
                        Ndir(
                          1,
                          horzcat(
                            mwVarargin(
                              mwVv(curdir, "curdir"), _mxarray55_)))));
            //
            // end
            //
            }
            //
            // set(files_handle,'Value',1);
            //
            ans.EqAns(
              Nset(
                0,
                mwVarargin(
                  mwVv(files_handle, "files_handle"),
                  _mxarray32_,
                  _mxarray7_)));
            //
            // set(files_handle,'String',files);
            //
            ans.EqAns(
              Nset(
                0,
                mwVarargin(
                  mwVv(files_handle, "files_handle"),
                  _mxarray30_,
                  mwVv(files, "files"))));
            //
            // set(directory_handle,'Value',1);
            //
            ans.EqAns(
              Nset(
                0,
                mwVarargin(
                  mwVv(directory_handle, "directory_handle"),
                  _mxarray32_,
                  _mxarray7_)));
            //
            // set(directory_handle,'String',directories);
            //
            ans.EqAns(
              Nset(
                0,
                mwVarargin(
                  mwVv(directory_handle, "directory_handle"),
                  _mxarray30_,
                  mwVv(directories, "directories"))));
            //
            // set(curdir_handle,'String',curdir);
            //
            ans.EqAns(
              Nset(
                0,
                mwVarargin(
                  mwVv(curdir_handle, "curdir_handle"),
                  _mxarray30_,
                  mwVv(curdir, "curdir"))));
            //
            // cd(datadir{2});
            //
            ans.EqAns(
              feval(
                mwAnsVarargout(),
                mlxCd,
                mwVarargin(mwVe(mwVsv(datadir, "datadir").cell(_mxarray8_)))));
            //
            // set(saveload_handle,'UserData',datadir);
            //
            ans.EqAns(
              Nset(
                0,
                mwVarargin(
                  mwVv(saveload_handle, "saveload_handle"),
                  _mxarray36_,
                  mwVv(datadir, "datadir"))));
        //
        // 
        // case 'MANUALCHANGEDIR'
        //
        } else if (switchcompare(v_, _mxarray57_)) {
            //
            // name = get(curdir_handle,'String');
            //
            name
              = Nget(
                  1,
                  mwVarargin(
                    mwVv(curdir_handle, "curdir_handle"), _mxarray30_));
            //
            // if(exist(name,'dir'))
            //
            if (tobool(mwVe(exist(mwVv(name, "name"), _mxarray59_)))) {
                //
                // set(file_handle,'String','');
                //
                ans.EqAns(
                  Nset(
                    0,
                    mwVarargin(
                      mwVv(file_handle, "file_handle"),
                      _mxarray30_,
                      _mxarray48_)));
                //
                // datadir=get(gcf,'UserData');
                //
                datadir = Nget(1, mwVarargin(mwVe(gcf()), _mxarray36_));
                //
                // cd(name);
                //
                ans.EqAns(Ncd(0, mwVv(name, "name")));
                //
                // curdir=cd;
                //
                curdir = Ncd(1, mwArray::DIN);
                //
                // if(curdir(end)=='\')
                //
                if (mclEqBool(
                      mwVe(
                        mclArrayRef(
                          mwVsv(curdir, "curdir"),
                          end(mwVv(curdir, "curdir"), _mxarray7_, _mxarray7_))),
                      _mxarray12_)) {
                    //
                    // datadir{1}=curdir(1:end-1);
                    //
                    datadir.cell(_mxarray7_)
                    = mclArrayRef(
                        mwVsv(curdir, "curdir"),
                        colon(
                          _mxarray7_,
                          end(mwVv(curdir, "curdir"), _mxarray7_, _mxarray7_)
                          - _mxarray7_));
                    //
                    // directories=ConvertToString(dir([curdir,'*.']));
                    //
                    directories
                      = SaveLoad_ConvertToString(
                          mwVe(
                            Ndir(
                              1,
                              horzcat(
                                mwVarargin(
                                  mwVv(curdir, "curdir"), _mxarray49_)))));
                    //
                    // files=ConvertToString(dir([curdir,'*.mat']));
                    //
                    files
                      = SaveLoad_ConvertToString(
                          mwVe(
                            Ndir(
                              1,
                              horzcat(
                                mwVarargin(
                                  mwVv(curdir, "curdir"), _mxarray51_)))));
                //
                // else
                //
                } else {
                    //
                    // datadir{1}=curdir;
                    //
                    datadir.cell(_mxarray7_) = mwVsv(curdir, "curdir");
                    //
                    // directories=ConvertToString(dir([curdir,'\*.']));
                    //
                    directories
                      = SaveLoad_ConvertToString(
                          mwVe(
                            Ndir(
                              1,
                              horzcat(
                                mwVarargin(
                                  mwVv(curdir, "curdir"), _mxarray53_)))));
                    //
                    // files=ConvertToString(dir([curdir,'\*.mat']));
                    //
                    files
                      = SaveLoad_ConvertToString(
                          mwVe(
                            Ndir(
                              1,
                              horzcat(
                                mwVarargin(
                                  mwVv(curdir, "curdir"), _mxarray55_)))));
                //
                // end
                //
                }
                //
                // set(files_handle,'Value',1);
                //
                ans.EqAns(
                  Nset(
                    0,
                    mwVarargin(
                      mwVv(files_handle, "files_handle"),
                      _mxarray32_,
                      _mxarray7_)));
                //
                // set(files_handle,'String',files);
                //
                ans.EqAns(
                  Nset(
                    0,
                    mwVarargin(
                      mwVv(files_handle, "files_handle"),
                      _mxarray30_,
                      mwVv(files, "files"))));
                //
                // set(directory_handle,'Value',1);
                //
                ans.EqAns(
                  Nset(
                    0,
                    mwVarargin(
                      mwVv(directory_handle, "directory_handle"),
                      _mxarray32_,
                      _mxarray7_)));
                //
                // set(directory_handle,'String',directories);
                //
                ans.EqAns(
                  Nset(
                    0,
                    mwVarargin(
                      mwVv(directory_handle, "directory_handle"),
                      _mxarray30_,
                      mwVv(directories, "directories"))));
                //
                // set(curdir_handle,'String',curdir);
                //
                ans.EqAns(
                  Nset(
                    0,
                    mwVarargin(
                      mwVv(curdir_handle, "curdir_handle"),
                      _mxarray30_,
                      mwVv(curdir, "curdir"))));
                //
                // cd(datadir{2});
                //
                ans.EqAns(
                  feval(
                    mwAnsVarargout(),
                    mlxCd,
                    mwVarargin(
                      mwVe(mwVsv(datadir, "datadir").cell(_mxarray8_)))));
                //
                // set(gcf,'UserData',datadir);
                //
                ans.EqAns(
                  Nset(
                    0,
                    mwVarargin(
                      mwVe(gcf()), _mxarray36_, mwVv(datadir, "datadir"))));
            //
            // end
            //
            }
        //
        // 
        // case 'FILE'
        //
        } else if (switchcompare(v_, _mxarray61_)) {
            //
            // set(file_handle,'String',name);
            //
            ans.EqAns(
              Nset(
                0,
                mwVarargin(
                  mwVv(file_handle, "file_handle"),
                  _mxarray30_,
                  mwVv(name, "name"))));
        //
        // 
        // case 'OK'
        //
        } else if (switchcompare(v_, _mxarray63_)) {
            //
            // title_handle = findobj(saveload_handle,'Tag','StaticText_title');
            //
            title_handle
              = findobj(
                  mwVarargin(
                    mwVv(saveload_handle, "saveload_handle"),
                    _mxarray14_,
                    _mxarray26_));
            //
            // msg = get(title_handle,'String');
            //
            msg
              = Nget(
                  1,
                  mwVarargin(mwVv(title_handle, "title_handle"), _mxarray30_));
            //
            // 
            // switch msg
            //
            {
                mwArray v_0(mwVv(msg, "msg"));
                if (switchcompare(v_0, _mxarray40_)) {
                    //
                    // 
                    // case 'SAVING DATA'
                    // name=get(file_handle,'String');
                    //
                    name
                      = Nget(
                          1,
                          mwVarargin(
                            mwVv(file_handle, "file_handle"), _mxarray30_));
                    //
                    // datadir=get(gcf,'UserData');
                    //
                    datadir = Nget(1, mwVarargin(mwVe(gcf()), _mxarray36_));
                    //
                    // file=[datadir{1},'\',name];
                    //
                    file
                      = horzcat(
                          mwVarargin(
                            mwVe(mwVsv(datadir, "datadir").cell(_mxarray7_)),
                            _mxarray12_,
                            mwVv(name, "name")));
                    //
                    // Save_Population_Data(file);
                    //
                    Save_Population_Data(mwVv(file, "file"));
                    //
                    // close(saveload_handle);
                    //
                    ans.EqAns(
                      Nclose(
                        0,
                        mwVarargin(mwVv(saveload_handle, "saveload_handle"))));
                //
                // 
                // case 'LOADING DATA'
                //
                } else if (switchcompare(v_0, _mxarray44_)) {
                    //
                    // name=get(file_handle,'String');
                    //
                    name
                      = Nget(
                          1,
                          mwVarargin(
                            mwVv(file_handle, "file_handle"), _mxarray30_));
                    //
                    // datadir=get(gcf,'UserData');
                    //
                    datadir = Nget(1, mwVarargin(mwVe(gcf()), _mxarray36_));
                    //
                    // file=[datadir{1},'\',name];
                    //
                    file
                      = horzcat(
                          mwVarargin(
                            mwVe(mwVsv(datadir, "datadir").cell(_mxarray7_)),
                            _mxarray12_,
                            mwVv(name, "name")));
                    //
                    // Load_Population_Data(file);
                    //
                    Load_Population_Data(mwVv(file, "file"));
                    //
                    // close(saveload_handle);
                    //
                    ans.EqAns(
                      Nclose(
                        0,
                        mwVarargin(mwVv(saveload_handle, "saveload_handle"))));
                //
                // end
                //
                }
            }
        //
        // 
        // end
        //
        }
    }
    //
    // 
    // %---------------------------------------------------------------
    // function str=ConvertToString(field)
    // 
    // L=length(field);
    // if(L==0)
    // str={};
    // else
    // for i=1:L
    // str(i)={getfield(field(i),'name')};
    // end
    // end
    //
}

//
// The function "MSaveLoad_ConvertToString" is the implementation version of
// the "SaveLoad/ConvertToString" M-function from file
// "C:\shu\hier_community_exe\SaveLoad.m" (lines 119-128). 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 str=ConvertToString(field)
//
static mwArray MSaveLoad_ConvertToString(int nargout_, mwArray field) {
    mwLocalFunctionTable save_local_function_table_
      (&_local_function_table_SaveLoad);
    mwArray str(mclGetUninitializedArray());
    mwArray i(mclGetUninitializedArray());
    mwArray L(mclGetUninitializedArray());
    //
    // 
    // L=length(field);
    //
    L = mclLengthInt(mwVa(field, "field"));
    //
    // if(L==0)
    //
    if (mclEqBool(mwVv(L, "L"), _mxarray65_)) {
        //
        // str={};
        //
        str = _mxarray66_;
    //
    // else
    //
    } else {
        //
        // for i=1:L
        //
        int v_(mclForIntStart(1));
        int e_(mclForIntEnd(mwVv(L, "L")));
        if (v_ > e_) {
            i = _mxarray6_;
        } else {
            //
            // str(i)={getfield(field(i),'name')};
            // end
            //
            for (; ; ) {
                mclIntArrayAssign(
                  &str,
                  cellhcat(
                    mwVarargin(
                      mwVe(
                        getfield(
                          mwVe(mclIntArrayRef(mwVsa(field, "field"), v_)),
                          mwVarargin(_mxarray67_))))),
                  v_);
                if (v_ == e_) {
                    break;
                }
                ++v_;
            }
            i = v_;
        }
    //
    // end
    //
    }
    mwValidateOutput(str, 1, nargout_, "str", "SaveLoad/ConvertToString");
    return str;
}
