//
// 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 "Default.hpp"
#include "libmatlbm.hpp"
#include "libmmfile.hpp"

static mxChar _array1_[132] = { 'R', 'u', 'n', '-', 't', 'i', 'm', 'e', ' ',
                                'E', 'r', 'r', 'o', 'r', ':', ' ', 'F', 'i',
                                'l', 'e', ':', ' ', 'D', 'e', 'f', 'a', 'u',
                                'l', 't', ' ', 'L', 'i', 'n', 'e', ':', ' ',
                                '1', ' ', 'C', 'o', 'l', 'u', 'm', 'n', ':',
                                ' ', '1', ' ', 'T', 'h', 'e', ' ', 'f', 'u',
                                'n', 'c', 't', 'i', 'o', 'n', ' ', '"', 'D',
                                'e', 'f', 'a', 'u', 'l', 't', '"', ' ', '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(132, _array1_);

static mxChar _array3_[131] = { 'R', 'u', 'n', '-', 't', 'i', 'm', 'e', ' ',
                                'E', 'r', 'r', 'o', 'r', ':', ' ', 'F', 'i',
                                'l', 'e', ':', ' ', 'D', 'e', 'f', 'a', 'u',
                                'l', 't', ' ', 'L', 'i', 'n', 'e', ':', ' ',
                                '1', ' ', 'C', 'o', 'l', 'u', 'm', 'n', ':',
                                ' ', '1', ' ', 'T', 'h', 'e', ' ', 'f', 'u',
                                'n', 'c', 't', 'i', 'o', 'n', ' ', '"', 'D',
                                'e', 'f', 'a', 'u', 'l', 't', '"', ' ', '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',
                                ' ', '(', '0', ')', '.' };
static mwArray _mxarray2_ = mclInitializeString(131, _array3_);

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

static mxChar _array7_[23] = { 'F', 'i', 'g', '_', 'm', 'u', 'l', 't',
                               'i', 'p', 'l', 'e', '_', 'p', 'o', 'p',
                               'u', 'l', 'a', 't', 'i', 'o', 'n' };
static mwArray _mxarray6_ = mclInitializeString(23, _array7_);

static mxChar _array9_[30] = { 'E', 'd', 'i', 't', 'T', 'e', 'x', 't',
                               '_', 'n', 'u', 'm', 'b', 'e', 'r', '_',
                               'o', 'f', '_', 'p', 'o', 'p', 'u', 'l',
                               'a', 't', 'i', 'o', 'n', 's' };
static mwArray _mxarray8_ = mclInitializeString(30, _array9_);

static mxChar _array11_[21] = { 'P', 'o', 'p', 'u', 'p', 'M', 'e',
                                'n', 'u', '_', 'p', 'o', 'p', 'u',
                                'l', 'a', 't', 'i', 'o', 'n', 's' };
static mwArray _mxarray10_ = mclInitializeString(21, _array11_);

static mxChar _array13_[21] = { 'E', 'd', 'i', 't', 'T', 'e', 'x',
                                't', '_', 'm', 'a', 'x', 'i', 'm',
                                'u', 'm', '_', 't', 'i', 'm', 'e' };
static mwArray _mxarray12_ = mclInitializeString(21, _array13_);

static mxChar _array15_[29] = { 'E', 'd', 'i', 't', 'T', 'e', 'x', 't',
                                '_', 'n', 'u', 'm', 'b', 'e', 'r', '_',
                                'o', 'f', '_', 't', 'i', 'm', 'e', '_',
                                's', 't', 'e', 'p', 's' };
static mwArray _mxarray14_ = mclInitializeString(29, _array15_);

static mxChar _array17_[18] = { 'E', 'd', 'i', 't', 'T', 'e', 'x', 't', '_',
                                'm', 'a', 'x', 'i', 'm', 'u', 'm', '_', 'x' };
static mwArray _mxarray16_ = mclInitializeString(18, _array17_);

static mxChar _array19_[30] = { 'E', 'd', 'i', 't', 'T', 'e', 'x', 't',
                                '_', 'n', 'u', 'm', 'b', 'e', 'r', '_',
                                'o', 'f', '_', 'x', '_', 'i', 'n', 't',
                                'e', 'r', 'v', 'a', 'l', 's' };
static mwArray _mxarray18_ = mclInitializeString(30, _array19_);

static mxChar _array21_[11] = { 'E', 'd', 'i', 't', 'T', 'e',
                                'x', 't', '_', 'u', 'o' };
static mwArray _mxarray20_ = mclInitializeString(11, _array21_);

static mxChar _array23_[20] = { 'E', 'd', 'i', 't', 'T', 'e', 'x',
                                't', '_', 'g', 'r', 'o', 'w', 't',
                                'h', '_', 'r', 'a', 't', 'e' };
static mwArray _mxarray22_ = mclInitializeString(20, _array23_);

static mxChar _array25_[22] = { 'E', 'd', 'i', 't', 'T', 'e', 'x', 't',
                                '_', 'm', 'o', 'r', 'a', 'l', 'i', 't',
                                'y', '_', 'r', 'a', 't', 'e' };
static mwArray _mxarray24_ = mclInitializeString(22, _array25_);

static mxChar _array27_[26] = { 'E', 'd', 'i', 't', 'T', 'e', 'x', 't', '_',
                                'r', 'e', 'p', 'r', 'o', 'd', 'u', 'c', 't',
                                'i', 'o', 'n', '_', 'r', 'a', 't', 'e' };
static mwArray _mxarray26_ = mclInitializeString(26, _array27_);

static mxChar _array29_[15] = { 'E', 'd', 'i', 't', 'T', 'e', 'x', 't',
                                '_', 'i', 'n', 'f', 'l', 'o', 'w' };
static mwArray _mxarray28_ = mclInitializeString(15, _array29_);

static mxChar _array31_[26] = { 'E', 'd', 'i', 't', 'T', 'e', 'x', 't', '_',
                                'w', 'e', 'i', 'g', 'h', 'i', 'n', 'g', '_',
                                'f', 'u', 'n', 'c', 't', 'i', 'o', 'n' };
static mwArray _mxarray30_ = mclInitializeString(26, _array31_);

static mxChar _array33_[20] = { 'E', 'd', 'i', 't', 'T', 'e', 'x',
                                't', '_', 'P', 'r', 'o', 'b', 'a',
                                'b', 'i', 'l', 'i', 't', 'y' };
static mwArray _mxarray32_ = mclInitializeString(20, _array33_);

static mxChar _array35_[16] = { 'R', 'a', 'd', 'i', 'o', 'b', 'u', 't',
                                't', 'o', 'n', '_', 'c', 'o', 'n', 't' };
static mwArray _mxarray34_ = mclInitializeString(16, _array35_);

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

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

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

static mxChar _array43_[2] = { 'P', '1' };
static mwArray _mxarray42_ = mclInitializeString(2, _array43_);
static mwArray _mxarray44_ = mclInitializeDoubleVector(0, 0, (double *)NULL);

static mxChar _array46_[2] = { '+', 'P' };
static mwArray _mxarray45_ = mclInitializeString(2, _array46_);

static mxChar _array48_[2] = { '*', 'P' };
static mwArray _mxarray47_ = mclInitializeString(2, _array48_);
static mwArray _mxarray49_ = mclInitializeDouble(3.0);

static mxChar _array51_[2] = { 'u', 'o' };
static mwArray _mxarray50_ = mclInitializeString(2, _array51_);

static mxChar _array53_[20] = { '3', '*', 'e', 'x', 'p', '(', '-',
                                '1', '0', '*', '(', 'x', '-', '.',
                                '0', '1', ')', '^', '2', ')' };
static mwArray _mxarray52_ = mclInitializeString(20, _array53_);

static mxChar _array55_[1] = { 'g' };
static mwArray _mxarray54_ = mclInitializeString(1, _array55_);

static mxChar _array57_[3] = { '5', '*', '(' };
static mwArray _mxarray56_ = mclInitializeString(3, _array57_);

static mxChar _array59_[10] = { ')', '*', 'e', 'x', 'p',
                                '(', '-', '2', '*', '(' };
static mwArray _mxarray58_ = mclInitializeString(10, _array59_);

static mxChar _array61_[8] = { ')', ')', '*', '(', '1', '-', 'x', ')' };
static mwArray _mxarray60_ = mclInitializeString(8, _array61_);

static mxChar _array63_[1] = { 'm' };
static mwArray _mxarray62_ = mclInitializeString(1, _array63_);

static mxChar _array65_[1] = { '(' };
static mwArray _mxarray64_ = mclInitializeString(1, _array65_);

static mxChar _array67_[5] = { ')', '/', '(', '1', '+' };
static mwArray _mxarray66_ = mclInitializeString(5, _array67_);

static mxChar _array69_[1] = { ')' };
static mwArray _mxarray68_ = mclInitializeString(1, _array69_);

static mxChar _array71_[1] = { 'b' };
static mwArray _mxarray70_ = mclInitializeString(1, _array71_);

static mxChar _array73_[14] = { '0', '.', '2', '*', 'e', 'x', 'p',
                                '(', '-', '0', '.', '2', '*', '(' };
static mwArray _mxarray72_ = mclInitializeString(14, _array73_);

static mxChar _array75_[4] = { ')', ')', '*', 'x' };
static mwArray _mxarray74_ = mclInitializeString(4, _array75_);

static mxChar _array77_[1] = { 'c' };
static mwArray _mxarray76_ = mclInitializeString(1, _array77_);

static mxChar _array79_[1] = { '0' };
static mwArray _mxarray78_ = mclInitializeString(1, _array79_);

static mxChar _array81_[1] = { 'w' };
static mwArray _mxarray80_ = mclInitializeString(1, _array81_);

static mxChar _array83_[20] = { '(', '0', '.', '2', '*', '(', 'y',
                                '<', '=', 'x', ')', '+', '(', 'y',
                                '>', 'x', ')', ')', '*', 'y' };
static mwArray _mxarray82_ = mclInitializeString(20, _array83_);

static mxChar _array85_[3] = { 'g', 'a', 'm' };
static mwArray _mxarray84_ = mclInitializeString(3, _array85_);

static mxChar _array87_[2] = { '1', '/' };
static mwArray _mxarray86_ = mclInitializeString(2, _array87_);

static mxChar _array89_[8] = { '*', 'o', 'n', 'e', 's', '(', '1', ',' };
static mwArray _mxarray88_ = mclInitializeString(8, _array89_);

static mxChar _array91_[3] = { '1', '.', '5' };
static mwArray _mxarray90_ = mclInitializeString(3, _array91_);

static mxChar _array93_[3] = { '1', '5', '0' };
static mwArray _mxarray92_ = mclInitializeString(3, _array93_);

static mxChar _array95_[1] = { '1' };
static mwArray _mxarray94_ = mclInitializeString(1, _array95_);

static mxChar _array97_[3] = { '1', '0', '0' };
static mwArray _mxarray96_ = mclInitializeString(3, _array97_);
static mwArray _mxarray98_ = mclInitializeDouble(1.0);

void InitializeModule_Default() {
}

void TerminateModule_Default() {
}

static void MDefault();

_mexLocalFunctionTable _local_function_table_Default
  = { 0, (mexFunctionTableEntry *)NULL };

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

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

//
// The function "MDefault" is the implementation version of the "Default"
// M-function from file "C:\shu\hier_community_exe\Default.m" (lines 1-58). 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 Default
//
static void MDefault() {
    mwLocalFunctionTable save_local_function_table_
      (&_local_function_table_Default);
    mwArray ans(mclGetUninitializedArray());
    mwArray i(mclGetUninitializedArray());
    mwArray Pmul(mclGetUninitializedArray());
    mwArray Psum(mclGetUninitializedArray());
    mwArray num_pop(mclGetUninitializedArray());
    mwArray parameters(mclGetUninitializedArray());
    mwArray current_population(mclGetUninitializedArray());
    mwArray cont_handle(mclGetUninitializedArray());
    mwArray probability_handle(mclGetUninitializedArray());
    mwArray weighing_function_handle(mclGetUninitializedArray());
    mwArray inflow_handle(mclGetUninitializedArray());
    mwArray reproduction_rate_handle(mclGetUninitializedArray());
    mwArray morality_rate_handle(mclGetUninitializedArray());
    mwArray growth_rate_handle(mclGetUninitializedArray());
    mwArray uo_handle(mclGetUninitializedArray());
    mwArray number_of_x_intervals_handle(mclGetUninitializedArray());
    mwArray maximum_x_handle(mclGetUninitializedArray());
    mwArray number_of_time_steps_handle(mclGetUninitializedArray());
    mwArray maximum_time_handle(mclGetUninitializedArray());
    mwArray populations_handle(mclGetUninitializedArray());
    mwArray number_of_populations_handle(mclGetUninitializedArray());
    mwArray multiple_population_handle(mclGetUninitializedArray());
    //
    // 
    // multiple_population_handle = findobj('Tag','Fig_multiple_population');
    //
    multiple_population_handle = findobj(mwVarargin(_mxarray4_, _mxarray6_));
    //
    // 
    // number_of_populations_handle = findobj(multiple_population_handle,'Tag','EditText_number_of_populations');
    //
    number_of_populations_handle
      = findobj(
          mwVarargin(
            mwVv(multiple_population_handle, "multiple_population_handle"),
            _mxarray4_,
            _mxarray8_));
    //
    // populations_handle = findobj(multiple_population_handle,'Tag','PopupMenu_populations');
    //
    populations_handle
      = findobj(
          mwVarargin(
            mwVv(multiple_population_handle, "multiple_population_handle"),
            _mxarray4_,
            _mxarray10_));
    //
    // maximum_time_handle = findobj(multiple_population_handle,'Tag','EditText_maximum_time');
    //
    maximum_time_handle
      = findobj(
          mwVarargin(
            mwVv(multiple_population_handle, "multiple_population_handle"),
            _mxarray4_,
            _mxarray12_));
    //
    // number_of_time_steps_handle = findobj(multiple_population_handle,'Tag','EditText_number_of_time_steps');
    //
    number_of_time_steps_handle
      = findobj(
          mwVarargin(
            mwVv(multiple_population_handle, "multiple_population_handle"),
            _mxarray4_,
            _mxarray14_));
    //
    // maximum_x_handle = findobj(multiple_population_handle,'Tag','EditText_maximum_x');
    //
    maximum_x_handle
      = findobj(
          mwVarargin(
            mwVv(multiple_population_handle, "multiple_population_handle"),
            _mxarray4_,
            _mxarray16_));
    //
    // number_of_x_intervals_handle = findobj(multiple_population_handle,'Tag','EditText_number_of_x_intervals');
    //
    number_of_x_intervals_handle
      = findobj(
          mwVarargin(
            mwVv(multiple_population_handle, "multiple_population_handle"),
            _mxarray4_,
            _mxarray18_));
    //
    // uo_handle = findobj(multiple_population_handle,'Tag','EditText_uo');
    //
    uo_handle
      = findobj(
          mwVarargin(
            mwVv(multiple_population_handle, "multiple_population_handle"),
            _mxarray4_,
            _mxarray20_));
    //
    // growth_rate_handle = findobj(multiple_population_handle,'Tag','EditText_growth_rate');
    //
    growth_rate_handle
      = findobj(
          mwVarargin(
            mwVv(multiple_population_handle, "multiple_population_handle"),
            _mxarray4_,
            _mxarray22_));
    //
    // morality_rate_handle = findobj(multiple_population_handle,'Tag','EditText_morality_rate');
    //
    morality_rate_handle
      = findobj(
          mwVarargin(
            mwVv(multiple_population_handle, "multiple_population_handle"),
            _mxarray4_,
            _mxarray24_));
    //
    // reproduction_rate_handle = findobj(multiple_population_handle,'Tag','EditText_reproduction_rate');
    //
    reproduction_rate_handle
      = findobj(
          mwVarargin(
            mwVv(multiple_population_handle, "multiple_population_handle"),
            _mxarray4_,
            _mxarray26_));
    //
    // inflow_handle = findobj(multiple_population_handle,'Tag','EditText_inflow');
    //
    inflow_handle
      = findobj(
          mwVarargin(
            mwVv(multiple_population_handle, "multiple_population_handle"),
            _mxarray4_,
            _mxarray28_));
    //
    // weighing_function_handle = findobj(multiple_population_handle,'Tag','EditText_weighing_function');
    //
    weighing_function_handle
      = findobj(
          mwVarargin(
            mwVv(multiple_population_handle, "multiple_population_handle"),
            _mxarray4_,
            _mxarray30_));
    //
    // probability_handle=findobj(multiple_population_handle,'Tag','EditText_Probability');
    //
    probability_handle
      = findobj(
          mwVarargin(
            mwVv(multiple_population_handle, "multiple_population_handle"),
            _mxarray4_,
            _mxarray32_));
    //
    // cont_handle = findobj(multiple_population_handle,'Tag','Radiobutton_cont');
    //
    cont_handle
      = findobj(
          mwVarargin(
            mwVv(multiple_population_handle, "multiple_population_handle"),
            _mxarray4_,
            _mxarray34_));
    //
    // 
    // current_population = get(populations_handle,'Value');
    //
    current_population
      = Nget(
          1,
          mwVarargin(
            mwVv(populations_handle, "populations_handle"), _mxarray36_));
    //
    // 
    // parameters = get(multiple_population_handle,'UserData');
    //
    parameters
      = Nget(
          1,
          mwVarargin(
            mwVv(multiple_population_handle, "multiple_population_handle"),
            _mxarray38_));
    //
    // 
    // num_pop = str2num(get(number_of_populations_handle,'String'));
    //
    num_pop
      = str2num(
          mwVe(
            Nget(
              1,
              mwVarargin(
                mwVv(
                  number_of_populations_handle,
                  "number_of_populations_handle"),
                _mxarray40_))));
    //
    // 
    // Psum = 'P1';
    //
    Psum = _mxarray42_;
    //
    // Pmul = 'P1';
    //
    Pmul = _mxarray42_;
    //
    // for i = 2:num_pop
    //
    {
        int v_(mclForIntStart(2));
        int e_(mclForIntEnd(mwVv(num_pop, "num_pop")));
        if (v_ > e_) {
            i = _mxarray44_;
        } else {
            //
            // Psum = [Psum,'+P',num2str(i)];
            // Pmul = [Pmul,'*P',num2str(i)];
            // end
            //
            for (; ; ) {
                Psum
                  = horzcat(
                      mwVarargin(
                        mwVv(Psum, "Psum"),
                        _mxarray45_,
                        mwVe(num2str(mwArray(v_)))));
                Pmul
                  = horzcat(
                      mwVarargin(
                        mwVv(Pmul, "Pmul"),
                        _mxarray47_,
                        mwVe(num2str(mwArray(v_)))));
                if (v_ == e_) {
                    break;
                }
                ++v_;
            }
            i = v_;
        }
    }
    //
    // 
    // for i = 1:num_pop
    //
    {
        int v_(mclForIntStart(1));
        int e_(mclForIntEnd(mwVv(num_pop, "num_pop")));
        if (v_ > e_) {
            i = _mxarray44_;
        } else {
            //
            // parameters{3}(i) = setfield(parameters{3}(current_population),'uo','3*exp(-10*(x-.01)^2)');
            // parameters{3}(i) = setfield(parameters{3}(current_population),'g',['5*(',Psum,')*exp(-2*(',Psum,'))*(1-x)']);
            // parameters{3}(i) = setfield(parameters{3}(current_population),'m',['(',Psum,')/(1+',Psum,')']);
            // parameters{3}(i) = setfield(parameters{3}(current_population),'b',['0.2*exp(-0.2*(',Psum,'))*x']);
            // parameters{3}(i) = setfield(parameters{3}(current_population),'c','0');
            // parameters{3}(i) = setfield(parameters{3}(current_population),'w','(0.2*(y<=x)+(y>x))*y');
            // parameters{3}(i) = setfield(parameters{3}(current_population),'gam',['1/',num2str(num_pop),'*ones(1,',num2str(num_pop),')']);
            // end
            //
            for (; ; ) {
                parameters.cell(_mxarray49_)(v_)
                = feval(
                    mwValueVarargout(),
                    mlxSetfield,
                    mwVarargin(
                      mwVe(
                        mwVsv(parameters, "parameters").cell(_mxarray49_)(
                          mwVsv(current_population, "current_population"))),
                      _mxarray50_,
                      _mxarray52_));
                parameters.cell(_mxarray49_)(v_)
                = feval(
                    mwValueVarargout(),
                    mlxSetfield,
                    mwVarargin(
                      mwVe(
                        mwVsv(parameters, "parameters").cell(_mxarray49_)(
                          mwVsv(current_population, "current_population"))),
                      _mxarray54_,
                      horzcat(
                        mwVarargin(
                          _mxarray56_,
                          mwVv(Psum, "Psum"),
                          _mxarray58_,
                          mwVv(Psum, "Psum"),
                          _mxarray60_))));
                parameters.cell(_mxarray49_)(v_)
                = feval(
                    mwValueVarargout(),
                    mlxSetfield,
                    mwVarargin(
                      mwVe(
                        mwVsv(parameters, "parameters").cell(_mxarray49_)(
                          mwVsv(current_population, "current_population"))),
                      _mxarray62_,
                      horzcat(
                        mwVarargin(
                          _mxarray64_,
                          mwVv(Psum, "Psum"),
                          _mxarray66_,
                          mwVv(Psum, "Psum"),
                          _mxarray68_))));
                parameters.cell(_mxarray49_)(v_)
                = feval(
                    mwValueVarargout(),
                    mlxSetfield,
                    mwVarargin(
                      mwVe(
                        mwVsv(parameters, "parameters").cell(_mxarray49_)(
                          mwVsv(current_population, "current_population"))),
                      _mxarray70_,
                      horzcat(
                        mwVarargin(
                          _mxarray72_, mwVv(Psum, "Psum"), _mxarray74_))));
                parameters.cell(_mxarray49_)(v_)
                = feval(
                    mwValueVarargout(),
                    mlxSetfield,
                    mwVarargin(
                      mwVe(
                        mwVsv(parameters, "parameters").cell(_mxarray49_)(
                          mwVsv(current_population, "current_population"))),
                      _mxarray76_,
                      _mxarray78_));
                parameters.cell(_mxarray49_)(v_)
                = feval(
                    mwValueVarargout(),
                    mlxSetfield,
                    mwVarargin(
                      mwVe(
                        mwVsv(parameters, "parameters").cell(_mxarray49_)(
                          mwVsv(current_population, "current_population"))),
                      _mxarray80_,
                      _mxarray82_));
                parameters.cell(_mxarray49_)(v_)
                = feval(
                    mwValueVarargout(),
                    mlxSetfield,
                    mwVarargin(
                      mwVe(
                        mwVsv(parameters, "parameters").cell(_mxarray49_)(
                          mwVsv(current_population, "current_population"))),
                      _mxarray84_,
                      horzcat(
                        mwVarargin(
                          _mxarray86_,
                          mwVe(num2str(mwVv(num_pop, "num_pop"))),
                          _mxarray88_,
                          mwVe(num2str(mwVv(num_pop, "num_pop"))),
                          _mxarray68_))));
                if (v_ == e_) {
                    break;
                }
                ++v_;
            }
            i = v_;
        }
    }
    //
    // 
    // set(multiple_population_handle,'UserData',parameters);
    //
    ans.EqAns(
      Nset(
        0,
        mwVarargin(
          mwVv(multiple_population_handle, "multiple_population_handle"),
          _mxarray38_,
          mwVv(parameters, "parameters"))));
    //
    // 
    // set(maximum_time_handle,'String','1.5');
    //
    ans.EqAns(
      Nset(
        0,
        mwVarargin(
          mwVv(maximum_time_handle, "maximum_time_handle"),
          _mxarray40_,
          _mxarray90_)));
    //
    // set(number_of_time_steps_handle,'String','150');
    //
    ans.EqAns(
      Nset(
        0,
        mwVarargin(
          mwVv(number_of_time_steps_handle, "number_of_time_steps_handle"),
          _mxarray40_,
          _mxarray92_)));
    //
    // set(maximum_x_handle,'String','1');
    //
    ans.EqAns(
      Nset(
        0,
        mwVarargin(
          mwVv(maximum_x_handle, "maximum_x_handle"),
          _mxarray40_,
          _mxarray94_)));
    //
    // set(number_of_x_intervals_handle,'String','100');
    //
    ans.EqAns(
      Nset(
        0,
        mwVarargin(
          mwVv(number_of_x_intervals_handle, "number_of_x_intervals_handle"),
          _mxarray40_,
          _mxarray96_)));
    //
    // set(uo_handle,'String','3*exp(-10*(x-.01)^2)');
    //
    ans.EqAns(
      Nset(
        0, mwVarargin(mwVv(uo_handle, "uo_handle"), _mxarray40_, _mxarray52_)));
    //
    // set(growth_rate_handle,'String',['5*(',Psum,')*exp(-2*(',Psum,'))*(1-x)']);
    //
    ans.EqAns(
      Nset(
        0,
        mwVarargin(
          mwVv(growth_rate_handle, "growth_rate_handle"),
          _mxarray40_,
          horzcat(
            mwVarargin(
              _mxarray56_,
              mwVv(Psum, "Psum"),
              _mxarray58_,
              mwVv(Psum, "Psum"),
              _mxarray60_)))));
    //
    // set(morality_rate_handle,'String',['(',Psum,')/(1+',Psum,')']);
    //
    ans.EqAns(
      Nset(
        0,
        mwVarargin(
          mwVv(morality_rate_handle, "morality_rate_handle"),
          _mxarray40_,
          horzcat(
            mwVarargin(
              _mxarray64_,
              mwVv(Psum, "Psum"),
              _mxarray66_,
              mwVv(Psum, "Psum"),
              _mxarray68_)))));
    //
    // set(reproduction_rate_handle,'String',['0.2*exp(-0.2*(',Psum,'))*x']);
    //
    ans.EqAns(
      Nset(
        0,
        mwVarargin(
          mwVv(reproduction_rate_handle, "reproduction_rate_handle"),
          _mxarray40_,
          horzcat(mwVarargin(_mxarray72_, mwVv(Psum, "Psum"), _mxarray74_)))));
    //
    // set(inflow_handle,'String','0');
    //
    ans.EqAns(
      Nset(
        0,
        mwVarargin(
          mwVv(inflow_handle, "inflow_handle"), _mxarray40_, _mxarray78_)));
    //
    // set(weighing_function_handle,'String','(0.2*(y<=x)+(y>x))*y');
    //
    ans.EqAns(
      Nset(
        0,
        mwVarargin(
          mwVv(weighing_function_handle, "weighing_function_handle"),
          _mxarray40_,
          _mxarray82_)));
    //
    // set(probability_handle,'String',['1/',num2str(num_pop),'*ones(1,',num2str(num_pop),')']);
    //
    ans.EqAns(
      Nset(
        0,
        mwVarargin(
          mwVv(probability_handle, "probability_handle"),
          _mxarray40_,
          horzcat(
            mwVarargin(
              _mxarray86_,
              mwVe(num2str(mwVv(num_pop, "num_pop"))),
              _mxarray88_,
              mwVe(num2str(mwVv(num_pop, "num_pop"))),
              _mxarray68_)))));
    //
    // set(cont_handle,'Value',1);
    //
    ans.EqAns(
      Nset(
        0,
        mwVarargin(
          mwVv(cont_handle, "cont_handle"), _mxarray36_, _mxarray98_)));
    //
    // 
    //
}
