//
// MATLAB Compiler: 2.2
// Date: Wed Mar 10 16:44:48 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 "Store_Parameters.hpp"
#include "Find_Var.hpp"
#include "My_Eval.hpp"
#include "libmatlbm.hpp"
#include "libmmfile.hpp"
#include "libmwsglm.hpp"

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

static mxChar _array3_[149] = { 'R', 'u', 'n', '-', 't', 'i', 'm', 'e', ' ',
                                'E', 'r', 'r', 'o', 'r', ':', ' ', 'F', 'i',
                                'l', 'e', ':', ' ', 'S', 't', 'o', 'r', 'e',
                                '_', 'P', 'a', 'r', 'a', 'm', 'e', 't', 'e',
                                'r', 's', ' ', 'L', 'i', 'n', 'e', ':', ' ',
                                '1', ' ', 'C', 'o', 'l', 'u', 'm', 'n', ':',
                                ' ', '1', ' ', 'T', 'h', 'e', ' ', 'f', 'u',
                                'n', 'c', 't', 'i', 'o', 'n', ' ', '"', 'S',
                                't', 'o', 'r', 'e', '_', 'P', 'a', 'r', 'a',
                                'm', 'e', 't', 'e', 'r', 's', '"', ' ', '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(149, _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_[21] = { 'S', 't', 'a', 't', 'i', 'c', 'T',
                               'e', 'x', 't', '_', 's', 't', 'a',
                               't', 'u', 's', '_', 'b', 'a', 'r' };
static mwArray _mxarray8_ = mclInitializeString(21, _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_[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 _mxarray12_ = mclInitializeString(30, _array13_);

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

static mxChar _array17_[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 _mxarray16_ = mclInitializeString(29, _array17_);

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

static mxChar _array21_[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 _mxarray20_ = mclInitializeString(30, _array21_);

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

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

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

static mxChar _array29_[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 _mxarray28_ = mclInitializeString(26, _array29_);

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

static mxChar _array33_[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 _mxarray32_ = mclInitializeString(26, _array33_);

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

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

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

static mxChar _array41_[5] = { 'V', 'a', 'l', 'u', 'e' };
static mwArray _mxarray40_ = mclInitializeString(5, _array41_);
static mwArray _mxarray42_ = mclInitializeDoubleVector(0, 0, (double *)NULL);

static mxChar _array44_[1] = { 'P' };
static mwArray _mxarray43_ = mclInitializeString(1, _array44_);
static mwArray _mxarray45_ = mclInitializeDouble(0.0);

static mxChar _array47_[40] = { 'T', 'h', 'e', ' ', 'p', 'r', 'o', 'b',
                                'a', 'b', 'i', 'l', 'i', 't', 'y', ' ',
                                'm', 'u', 's', 't', ' ', 'b', 'e', ' ',
                                'b', 'e', 't', 'w', 'e', 'e', 'n', ' ',
                                '0', ' ', 'a', 'n', 'd', ' ', '1', '!' };
static mwArray _mxarray46_ = mclInitializeString(40, _array47_);

static mxChar _array49_[5] = { 'C', 'o', 'l', 'o', 'r' };
static mwArray _mxarray48_ = mclInitializeString(5, _array49_);

static mxChar _array51_[3] = { 'R', 'e', 'd' };
static mwArray _mxarray50_ = mclInitializeString(3, _array51_);
static mwArray _mxarray52_ = mclInitializeDouble(1.0);
static mwArray _mxarray53_ = mclInitializeDouble(3.0);

static mxChar _array55_[3] = { 'g', 'a', 'm' };
static mwArray _mxarray54_ = mclInitializeString(3, _array55_);
static mwArray _mxarray56_ = mclInitializeDouble(2.0);

static mxChar _array58_[43] = { 'T', 'h', 'e', ' ', 'm', 'a', 'x', 'i', 'm',
                                'u', 'm', ' ', 't', 'i', 'm', 'e', ' ', 'm',
                                'u', 's', 't', ' ', 'b', 'e', ' ', 'a', ' ',
                                'p', 'o', 's', 'i', 't', 'i', 'v', 'e', ' ',
                                'n', 'u', 'm', 'b', 'e', 'r', '!' };
static mwArray _mxarray57_ = mclInitializeString(43, _array58_);

static mxChar _array60_[47] = { 'T', 'h', 'e', ' ', '#', ' ', 'o', 'f',
                                ' ', 't', 'i', 'm', 'e', ' ', 's', 't',
                                'e', 'p', 's', ' ', 'm', 'u', 's', 't',
                                ' ', 'b', 'e', ' ', 'a', ' ', 'p', 'o',
                                's', 'i', 't', 'i', 'v', 'e', ' ', 'i',
                                'n', 't', 'e', 'g', 'e', 'r', '!' };
static mwArray _mxarray59_ = mclInitializeString(47, _array60_);

static mxChar _array62_[40] = { 'T', 'h', 'e', ' ', 'm', 'a', 'x', 'i',
                                'm', 'u', 'm', ' ', 'x', ' ', 'm', 'u',
                                's', 't', ' ', 'b', 'e', ' ', 'a', ' ',
                                'p', 'o', 's', 'i', 't', 'i', 'v', 'e',
                                ' ', 'n', 'u', 'm', 'b', 'e', 'r', '!' };
static mwArray _mxarray61_ = mclInitializeString(40, _array62_);

static mxChar _array64_[48] = { 'T', 'h', 'e', ' ', '#', ' ', 'o', 'f',
                                ' ', 'x', ' ', 'd', 'i', 'v', 'i', 's',
                                'i', 'o', 'n', 's', ' ', 'm', 'u', 's',
                                't', ' ', 'b', 'e', ' ', 'a', ' ', 'p',
                                'o', 's', 'i', 't', 'i', 'v', 'e', ' ',
                                'i', 'n', 't', 'e', 'g', 'e', 'r', '!' };
static mwArray _mxarray63_ = mclInitializeString(48, _array64_);
static mwArray _mxarray65_ = mclInitializeDouble(4.0);

static mxChar _array67_[45] = { 'T', 'h', 'e', ' ', 'I', 'n', 'i', 't', 'i',
                                'a', 'l', ' ', 'P', 'o', 'p', 'u', 'l', 'a',
                                't', 'i', 'o', 'n', ' ', 'D', 'i', 's', 't',
                                'r', 'i', 'b', 'u', 't', 'i', 'o', 'n', ' ',
                                'i', 's', ' ', 'e', 'm', 'p', 't', 'y', '!' };
static mwArray _mxarray66_ = mclInitializeString(45, _array67_);

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

static mxChar _array71_[63] = { 'T', 'h', 'e', ' ', 'I', 'n', 'i', 't', 'i',
                                'a', 'l', ' ', 'P', 'o', 'p', 'u', 'l', 'a',
                                't', 'i', 'o', 'n', ' ', 'D', 'i', 's', 't',
                                'r', 'i', 'b', 'u', 't', 'i', 'o', 'n', ' ',
                                'e', 'q', 'u', 'a', 't', 'i', 'o', 'n', ' ',
                                'o', 'n', 'l', 'y', ' ', 'd', 'e', 'p', 'e',
                                'n', 'd', 's', ' ', 'o', 'n', ' ', 'x', '!' };
static mwArray _mxarray70_ = mclInitializeString(63, _array71_);
static mxArray * _mxarray73_ = mclInitializeString(1, _array69_);
static mwArray _mxarray72_ = mclInitializeCell(_mxarray73_);

static mxChar _array75_[102] = { 's', 'e', 't', '(', 'e', 'r', 'r', 'o', 'r',
                                 'd', 'l', 'g', '(', 0x0027, 'T', 'h', 'e',
                                 'r', 'e', ' ', 'i', 's', ' ', 'a', ' ', 's',
                                 'y', 'n', 't', 'a', 'x', ' ', 'e', 'r', 'r',
                                 'o', 'r', ' ', 'i', 'n', ' ', 't', 'h', 'e',
                                 ' ', 'I', 'n', 'i', 't', 'i', 'a', 'l', ' ',
                                 'P', 'o', 'p', 'u', 'l', 'a', 't', 'i', 'o',
                                 'n', ' ', 'D', 'i', 's', 't', 'r', 'i', 'b',
                                 'u', 't', 'i', 'o', 'n', ' ', 'f', 'u', 'n',
                                 'c', 't', 'i', 'o', 'n', 0x0027, ')', ',',
                                 0x0027, 'C', 'o', 'l', 'o', 'r', 0x0027,
                                 ',', 0x0027, 'R', 'e', 'd', 0x0027, ')' };
static mwArray _mxarray74_ = mclInitializeString(102, _array75_);

static mxChar _array77_[60] = { 'I', 'n', 'i', 't', 'i', 'a', 'l', ' ', 'P',
                                'o', 'p', 'u', 'l', 'a', 't', 'i', 'o', 'n',
                                ' ', 'D', 'i', 's', 't', 'r', 'i', 'b', 'u',
                                't', 'i', 'o', 'n', ' ', 'f', 'u', 'n', 'c',
                                't', 'i', 'o', 'n', ' ', 'm', 'u', 's', 't',
                                ' ', 'b', 'e', ' ', 'n', 'o', 'n', 'n', 'e',
                                'g', 'a', 't', 'i', 'v', 'e' };
static mwArray _mxarray76_ = mclInitializeString(60, _array77_);

static mxChar _array79_[71] = { 'T', 'h', 'e', 'r', 'e', ' ', 'i', 's', ' ',
                                'a', ' ', 's', 'y', 'n', 't', 'a', 'x', ' ',
                                'e', 'r', 'r', 'o', 'r', ' ', 'i', 'n', ' ',
                                't', 'h', 'e', ' ', 'I', 'n', 'i', 't', 'i',
                                'a', 'l', ' ', 'P', 'o', 'p', 'u', 'l', 'a',
                                't', 'i', 'o', 'n', ' ', 'D', 'i', 's', 't',
                                'r', 'i', 'b', 'u', 't', 'i', 'o', 'n', ' ',
                                'f', 'u', 'n', 'c', 't', 'i', 'o', 'n' };
static mwArray _mxarray78_ = mclInitializeString(71, _array79_);

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

static mxChar _array83_[25] = { 'T', 'h', 'e', ' ', 'G', 'r', 'o', 'w', 't',
                                'h', ' ', 'R', 'a', 't', 'e', ' ', 'i', 's',
                                ' ', 'e', 'm', 'p', 't', 'y', '!' };
static mwArray _mxarray82_ = mclInitializeString(25, _array83_);

static mxChar _array85_[47] = { 'T', 'h', 'e', ' ', 'G', 'r', 'o', 'w',
                                't', 'h', ' ', 'R', 'a', 't', 'e', ' ',
                                'h', 'a', 's', ' ', 'v', 'a', 'r', 'i',
                                'a', 'b', 'l', 'e', 's', ' ', 'o', 'f',
                                ' ', 'x', ' ', 'a', 'n', 'd', ' ', 'P',
                                '1', ' ', 'o', 'n', 'l', 'y', '!' };
static mwArray _mxarray84_ = mclInitializeString(47, _array85_);

static mxChar _array87_[51] = { 'T', 'h', 'e', ' ', 'G', 'r', 'o', 'w', 't',
                                'h', ' ', 'R', 'a', 't', 'e', ' ', 'h', 'a',
                                's', ' ', 'v', 'a', 'r', 'i', 'a', 'b', 'l',
                                'e', 's', ' ', 'o', 'f', ' ', 'x', ',', ' ',
                                'P', '1', ' ', 'a', 'n', 'd', ' ', 'P', '2',
                                ' ', 'o', 'n', 'l', 'y', '!' };
static mwArray _mxarray86_ = mclInitializeString(51, _array87_);

static mxChar _array89_[47] = { 'T', 'h', 'e', ' ', 'G', 'r', 'o', 'w',
                                't', 'h', ' ', 'R', 'a', 't', 'e', ' ',
                                'h', 'a', 's', ' ', 'v', 'a', 'r', 'i',
                                'a', 'b', 'l', 'e', 's', ' ', 'o', 'f',
                                ' ', 'x', ',', ' ', 'P', '1', ',', ' ',
                                'P', '2', ',', '.', '.', '.', 'P' };
static mwArray _mxarray88_ = mclInitializeString(47, _array89_);

static mxChar _array91_[5] = { 'o', 'n', 'l', 'y', '!' };
static mwArray _mxarray90_ = mclInitializeString(5, _array91_);

static mxChar _array93_[82] = { 's', 'e', 't', '(', 'e', 'r', 'r', 'o', 'r',
                                'd', 'l', 'g', '(', 0x0027, 'T', 'h', 'e',
                                'r', 'e', ' ', 'i', 's', ' ', 'a', ' ', 's',
                                'y', 'n', 't', 'a', 'x', ' ', 'e', 'r', 'r',
                                'o', 'r', ' ', 'i', 'n', ' ', 't', 'h', 'e',
                                ' ', 'G', 'r', 'o', 'w', 't', 'h', ' ', 'R',
                                'a', 't', 'e', ' ', 'f', 'u', 'n', 'c', 't',
                                'i', 'o', 'n', 0x0027, ')', ',', 0x0027,
                                'C', 'o', 'l', 'o', 'r', 0x0027, ',',
                                0x0027, 'R', 'e', 'd', 0x0027, ')' };
static mwArray _mxarray92_ = mclInitializeString(82, _array93_);

static mxChar _array95_[40] = { 'G', 'r', 'o', 'w', 't', 'h', ' ', 'R',
                                'a', 't', 'e', ' ', 'f', 'u', 'n', 'c',
                                't', 'i', 'o', 'n', ' ', 'm', 'u', 's',
                                't', ' ', 'b', 'e', ' ', 'n', 'o', 'n',
                                'n', 'e', 'g', 'a', 't', 'i', 'v', 'e' };
static mwArray _mxarray94_ = mclInitializeString(40, _array95_);

static mxChar _array97_[51] = { 'T', 'h', 'e', 'r', 'e', ' ', 'i', 's', ' ',
                                'a', ' ', 's', 'y', 'n', 't', 'a', 'x', ' ',
                                'e', 'r', 'r', 'o', 'r', ' ', 'i', 'n', ' ',
                                't', 'h', 'e', ' ', 'G', 'r', 'o', 'w', 't',
                                'h', ' ', 'R', 'a', 't', 'e', ' ', 'f', 'u',
                                'n', 'c', 't', 'i', 'o', 'n' };
static mwArray _mxarray96_ = mclInitializeString(51, _array97_);

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

static mxChar _array101_[28] = { 'T', 'h', 'e', ' ', 'M', 'o', 'r',
                                 't', 'a', 'l', 'i', 't', 'y', ' ',
                                 'R', 'a', 't', 'e', ' ', 'i', 's',
                                 ' ', 'e', 'm', 'p', 't', 'y', '!' };
static mwArray _mxarray100_ = mclInitializeString(28, _array101_);

static mxChar _array103_[50] = { 'T', 'h', 'e', ' ', 'M', 'o', 'r', 't', 'a',
                                 'l', 'i', 't', 'y', ' ', 'R', 'a', 't', 'e',
                                 ' ', 'h', 'a', 's', ' ', 'v', 'a', 'r', 'i',
                                 'a', 'b', 'l', 'e', 's', ' ', 'o', 'f', ' ',
                                 'x', ' ', 'a', 'n', 'd', ' ', 'P', '1', ' ',
                                 'o', 'n', 'l', 'y', '!' };
static mwArray _mxarray102_ = mclInitializeString(50, _array103_);

static mxChar _array105_[54] = { 'T', 'h', 'e', ' ', 'M', 'o', 'r', 't', 'a',
                                 'l', 'i', 't', 'y', ' ', 'R', 'a', 't', 'e',
                                 ' ', 'h', 'a', 's', ' ', 'v', 'a', 'r', 'i',
                                 'a', 'b', 'l', 'e', 's', ' ', 'o', 'f', ' ',
                                 'x', ',', ' ', 'P', '1', ' ', 'a', 'n', 'd',
                                 ' ', 'P', '2', ' ', 'o', 'n', 'l', 'y', '!' };
static mwArray _mxarray104_ = mclInitializeString(54, _array105_);

static mxChar _array107_[50] = { 'T', 'h', 'e', ' ', 'M', 'o', 'r', 't', 'a',
                                 'l', 'i', 't', 'y', ' ', 'R', 'a', 't', 'e',
                                 ' ', 'h', 'a', 's', ' ', 'v', 'a', 'r', 'i',
                                 'a', 'b', 'l', 'e', 's', ' ', 'o', 'f', ' ',
                                 'x', ',', ' ', 'P', '1', ',', ' ', 'P', '2',
                                 ',', '.', '.', '.', 'P' };
static mwArray _mxarray106_ = mclInitializeString(50, _array107_);

static mxChar _array109_[6] = { ' ', 'o', 'n', 'l', 'y', '!' };
static mwArray _mxarray108_ = mclInitializeString(6, _array109_);

static mxChar _array111_[85] = { 's', 'e', 't', '(', 'e', 'r', 'r', 'o', 'r',
                                 'd', 'l', 'g', '(', 0x0027, 'T', 'h', 'e',
                                 'r', 'e', ' ', 'i', 's', ' ', 'a', ' ', 's',
                                 'y', 'n', 't', 'a', 'x', ' ', 'e', 'r', 'r',
                                 'o', 'r', ' ', 'i', 'n', ' ', 't', 'h', 'e',
                                 ' ', 'M', 'o', 'r', 't', 'a', 'l', 'i', 't',
                                 'y', ' ', 'R', 'a', 't', 'e', ' ', 'f', 'u',
                                 'n', 'c', 't', 'i', 'o', 'n', 0x0027, ')',
                                 ',', 0x0027, 'C', 'o', 'l', 'o', 'r', 0x0027,
                                 ',', 0x0027, 'R', 'e', 'd', 0x0027, ')' };
static mwArray _mxarray110_ = mclInitializeString(85, _array111_);

static mxChar _array113_[43] = { 'M', 'o', 'r', 't', 'a', 'l', 'i', 't', 'y',
                                 ' ', 'R', 'a', 't', 'e', ' ', 'f', 'u', 'n',
                                 'c', 't', 'i', 'o', 'n', ' ', 'm', 'u', 's',
                                 't', ' ', 'b', 'e', ' ', 'n', 'o', 'n', 'n',
                                 'e', 'g', 'a', 't', 'i', 'v', 'e' };
static mwArray _mxarray112_ = mclInitializeString(43, _array113_);

static mxChar _array115_[54] = { 'T', 'h', 'e', 'r', 'e', ' ', 'i', 's', ' ',
                                 'a', ' ', 's', 'y', 'n', 't', 'a', 'x', ' ',
                                 'e', 'r', 'r', 'o', 'r', ' ', 'i', 'n', ' ',
                                 't', 'h', 'e', ' ', 'M', 'o', 'r', 't', 'a',
                                 'l', 'i', 't', 'y', ' ', 'R', 'a', 't', 'e',
                                 ' ', 'f', 'u', 'n', 'c', 't', 'i', 'o', 'n' };
static mwArray _mxarray114_ = mclInitializeString(54, _array115_);

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

static mxChar _array119_[31] = { 'T', 'h', 'e', ' ', 'R', 'e', 'p', 'r',
                                 'o', 'd', 'c', 'u', 't', 'i', 'o', 'n',
                                 ' ', 'R', 'a', 't', 'e', ' ', 'i', 's',
                                 ' ', 'e', 'm', 'p', 't', 'y', '!' };
static mwArray _mxarray118_ = mclInitializeString(31, _array119_);

static mxChar _array121_[53] = { 'T', 'h', 'e', ' ', 'R', 'e', 'p', 'r', 'o',
                                 'd', 'u', 'c', 't', 'i', 'o', 'n', ' ', 'R',
                                 'a', 't', 'e', ' ', 'h', 'a', 's', ' ', 'v',
                                 'a', 'r', 'i', 'a', 'b', 'l', 'e', 's', ' ',
                                 'o', 'f', ' ', 'x', ' ', 'a', 'n', 'd', ' ',
                                 'P', '1', ' ', 'o', 'n', 'l', 'y', '!' };
static mwArray _mxarray120_ = mclInitializeString(53, _array121_);

static mxChar _array123_[57] = { 'T', 'h', 'e', ' ', 'R', 'e', 'p', 'r', 'o',
                                 'd', 'u', 'c', 't', 'i', 'o', 'n', ' ', 'R',
                                 'a', 't', 'e', ' ', 'h', 'a', 's', ' ', 'v',
                                 'a', 'r', 'i', 'a', 'b', 'l', 'e', 's', ' ',
                                 'o', 'f', ' ', 'x', ',', ' ', 'P', '1', ' ',
                                 'a', 'n', 'd', ' ', 'P', '2', ' ', 'o', 'n',
                                 'l', 'y', '!' };
static mwArray _mxarray122_ = mclInitializeString(57, _array123_);

static mxChar _array125_[53] = { 'T', 'h', 'e', ' ', 'R', 'e', 'p', 'r', 'o',
                                 'd', 'u', 'c', 't', 'i', 'o', 'n', ' ', 'R',
                                 'a', 't', 'e', ' ', 'h', 'a', 's', ' ', 'v',
                                 'a', 'r', 'i', 'a', 'b', 'l', 'e', 's', ' ',
                                 'o', 'f', ' ', 'x', ',', ' ', 'P', '1', ',',
                                 ' ', 'P', '2', ',', '.', '.', '.', 'P' };
static mwArray _mxarray124_ = mclInitializeString(53, _array125_);

static mxChar _array127_[88] = { 's', 'e', 't', '(', 'e', 'r', 'r', 'o', 'r',
                                 'd', 'l', 'g', '(', 0x0027, 'T', 'h', 'e',
                                 'r', 'e', ' ', 'i', 's', ' ', 'a', ' ', 's',
                                 'y', 'n', 't', 'a', 'x', ' ', 'e', 'r', 'r',
                                 'o', 'r', ' ', 'i', 'n', ' ', 't', 'h', 'e',
                                 ' ', 'R', 'e', 'p', 'r', 'o', 'd', 'u', 'c',
                                 't', 'i', 'o', 'n', ' ', 'R', 'a', 't', 'e',
                                 ' ', 'f', 'u', 'n', 'c', 't', 'i', 'o', 'n',
                                 0x0027, ')', ',', 0x0027, 'C', 'o', 'l',
                                 'o', 'r', 0x0027, ',', 0x0027, 'R', 'e',
                                 'd', 0x0027, ')' };
static mwArray _mxarray126_ = mclInitializeString(88, _array127_);

static mxChar _array129_[46] = { 'R', 'e', 'p', 'r', 'o', 'd', 'u', 'c',
                                 't', 'i', 'o', 'n', ' ', 'R', 'a', 't',
                                 'e', ' ', 'f', 'u', 'n', 'c', 't', 'i',
                                 'o', 'n', ' ', 'm', 'u', 's', 't', ' ',
                                 'b', 'e', ' ', 'n', 'o', 'n', 'n', 'e',
                                 'g', 'a', 't', 'i', 'v', 'e' };
static mwArray _mxarray128_ = mclInitializeString(46, _array129_);

static mxChar _array131_[57] = { 'T', 'h', 'e', 'r', 'e', ' ', 'i', 's', ' ',
                                 'a', ' ', 's', 'y', 'n', 't', 'a', 'x', ' ',
                                 'e', 'r', 'r', 'o', 'r', ' ', 'i', 'n', ' ',
                                 't', 'h', 'e', ' ', 'R', 'e', 'p', 'r', 'o',
                                 'd', 'u', 'c', 't', 'i', 'o', 'n', ' ', 'R',
                                 'a', 't', 'e', ' ', 'f', 'u', 'n', 'c', 't',
                                 'i', 'o', 'n' };
static mwArray _mxarray130_ = mclInitializeString(57, _array131_);

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

static mxChar _array135_[34] = { 'T', 'h', 'e', ' ', 'I', 'n', 'f', 'l', 'o',
                                 'w', ' ', 'o', 'f', ' ', 'Z', 'e', 'r', 'o',
                                 '-', 'S', 'i', 'z', 'e', 'd', ' ', 'i', 's',
                                 ' ', 'e', 'm', 'p', 't', 'y', '!' };
static mwArray _mxarray134_ = mclInitializeString(34, _array135_);

static mxChar _array137_[1] = { 't' };
static mwArray _mxarray136_ = mclInitializeString(1, _array137_);

static mxChar _array139_[52] = { 'T', 'h', 'e', ' ', 'I', 'n', 'f', 'l', 'o',
                                 'w', ' ', 'o', 'f', ' ', 'Z', 'e', 'r', 'o',
                                 '-', 'S', 'i', 'z', 'e', 'd', ' ', 'e', 'q',
                                 'u', 'a', 't', 'i', 'o', 'n', ' ', 'o', 'n',
                                 'l', 'y', ' ', 'd', 'e', 'p', 'e', 'n', 'd',
                                 's', ' ', 'o', 'n', ' ', 't', '!' };
static mwArray _mxarray138_ = mclInitializeString(52, _array139_);
static mxArray * _mxarray141_ = mclInitializeString(1, _array137_);
static mwArray _mxarray140_ = mclInitializeCell(_mxarray141_);

static mxChar _array143_[91] = { 's', 'e', 't', '(', 'e', 'r', 'r', 'o', 'r',
                                 'd', 'l', 'g', '(', 0x0027, 'T', 'h', 'e',
                                 'r', 'e', ' ', 'i', 's', ' ', 'a', ' ', 's',
                                 'y', 'n', 't', 'a', 'x', ' ', 'e', 'r', 'r',
                                 'o', 'r', ' ', 'i', 'n', ' ', 't', 'h', 'e',
                                 ' ', 'I', 'n', 'f', 'l', 'o', 'w', ' ', 'o',
                                 'f', ' ', 'Z', 'e', 'r', 'o', '-', 'S', 'i',
                                 'z', 'e', 'd', ' ', 'e', 'q', 'u', 'a', 't',
                                 'i', 'o', 'n', 0x0027, ')', ',', 0x0027,
                                 'C', 'o', 'l', 'o', 'r', 0x0027, ',',
                                 0x0027, 'R', 'e', 'd', 0x0027, ')' };
static mwArray _mxarray142_ = mclInitializeString(91, _array143_);

static mxChar _array145_[49] = { 'I', 'n', 'f', 'l', 'o', 'w', ' ', 'o', 'f',
                                 ' ', 'Z', 'e', 'r', 'o', '-', 'S', 'i', 'z',
                                 'e', 'd', ' ', 'f', 'u', 'n', 'c', 't', 'i',
                                 'o', 'n', ' ', 'm', 'u', 's', 't', ' ', 'b',
                                 'e', ' ', 'n', 'o', 'n', 'n', 'e', 'g', 'a',
                                 't', 'i', 'v', 'e' };
static mwArray _mxarray144_ = mclInitializeString(49, _array145_);

static mxChar _array147_[60] = { 'T', 'h', 'e', 'r', 'e', ' ', 'i', 's', ' ',
                                 'a', ' ', 's', 'y', 'n', 't', 'a', 'x', ' ',
                                 'e', 'r', 'r', 'o', 'r', ' ', 'i', 'n', ' ',
                                 't', 'h', 'e', ' ', 'I', 'n', 'f', 'l', 'o',
                                 'w', ' ', 'o', 'f', ' ', 'Z', 'e', 'r', 'o',
                                 '-', 'S', 'i', 'z', 'e', 'd', ' ', 'f', 'u',
                                 'n', 'c', 't', 'i', 'o', 'n' };
static mwArray _mxarray146_ = mclInitializeString(60, _array147_);

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

static mxChar _array151_[32] = { 'T', 'h', 'e', ' ', 'W', 'e', 'i', 'g',
                                 'h', 't', 'i', 'n', 'g', ' ', 'F', 'u',
                                 'n', 'c', 't', 'i', 'o', 'n', ' ', 'i',
                                 's', ' ', 'e', 'm', 'p', 't', 'y', '!' };
static mwArray _mxarray150_ = mclInitializeString(32, _array151_);

static mxChar _array153_[1] = { 'y' };
static mwArray _mxarray152_ = mclInitializeString(1, _array153_);

static mxChar _array155_[47] = { 'T', 'h', 'e', ' ', 'W', 'e', 'i', 'g',
                                 'h', 't', 'i', 'n', 'g', ' ', 'F', 'u',
                                 'n', 'c', 't', 'i', 'o', 'n', ' ', 'd',
                                 'e', 'p', 'e', 'n', 'd', 's', ' ', 'o',
                                 'n', ' ', 'x', ' ', 'a', 'n', 'd', ' ',
                                 'y', ' ', 'o', 'n', 'l', 'y', '!' };
static mwArray _mxarray154_ = mclInitializeString(47, _array155_);
static mxArray * _mxarray158_ = mclInitializeString(1, _array153_);

static mxArray * _array157_[2] = { _mxarray73_, _mxarray158_ };
static mwArray _mxarray156_ = mclInitializeCellVector(1, 2, _array157_);

static mxChar _array160_[80] = { 's', 'e', 't', '(', 'e', 'r', 'r', 'o', 'r',
                                 'd', 'l', 'g', '(', 0x0027, 'T', 'h', 'e',
                                 'r', 'e', ' ', 'i', 's', ' ', 'a', ' ', 's',
                                 'y', 'n', 't', 'a', 'x', ' ', 'e', 'r', 'r',
                                 'o', 'r', ' ', 'i', 'n', ' ', 't', 'h', 'e',
                                 ' ', 'W', 'e', 'i', 'g', 'h', 't', 'i', 'n',
                                 'g', ' ', 'F', 'u', 'n', 'c', 't', 'i', 'o',
                                 'n', 0x0027, ')', ',', 0x0027, 'C', 'o',
                                 'l', 'o', 'r', 0x0027, ',', 0x0027, 'R',
                                 'e', 'd', 0x0027, ')' };
static mwArray _mxarray159_ = mclInitializeString(80, _array160_);

static mxChar _array162_[37] = { 'W', 'e', 'i', 'g', 'h', 'i', 'n', 'g',
                                 ' ', 'f', 'u', 'n', 'c', 't', 'i', 'o',
                                 'n', ' ', 'm', 'u', 's', 't', ' ', 'b',
                                 'e', ' ', 'n', 'o', 'n', 'n', 'e', 'g',
                                 'a', 't', 'i', 'v', 'e' };
static mwArray _mxarray161_ = mclInitializeString(37, _array162_);

static mxChar _array164_[49] = { 'T', 'h', 'e', 'r', 'e', ' ', 'i', 's', ' ',
                                 'a', ' ', 's', 'y', 'n', 't', 'a', 'x', ' ',
                                 'e', 'r', 'r', 'o', 'r', ' ', 'i', 'n', ' ',
                                 't', 'h', 'e', ' ', 'W', 'e', 'i', 'g', 'h',
                                 't', 'i', 'n', 'g', ' ', 'F', 'u', 'n', 'c',
                                 't', 'i', 'o', 'n' };
static mwArray _mxarray163_ = mclInitializeString(49, _array164_);

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

static mxChar _array168_[15] = { 'B', 'a', 'c', 'k', 'g', 'r', 'o', 'u',
                                 'n', 'd', 'C', 'o', 'l', 'o', 'r' };
static mwArray _mxarray167_ = mclInitializeString(15, _array168_);

static mxChar _array170_[15] = { 'F', 'o', 'r', 'e', 'g', 'r', 'o', 'u',
                                 'n', 'd', 'C', 'o', 'l', 'o', 'r' };
static mwArray _mxarray169_ = mclInitializeString(15, _array170_);

static mxChar _array172_[5] = { 'W', 'h', 'i', 't', 'e' };
static mwArray _mxarray171_ = mclInitializeString(5, _array172_);

static mxChar _array174_[25] = { 'P', 'L', 'E', 'A', 'S', 'E', ' ', 'C', 'O',
                                 'R', 'R', 'E', 'C', 'T', ' ', 'Y', 'O', 'U',
                                 'R', ' ', 'E', 'R', 'R', 'O', 'R' };
static mwArray _mxarray173_ = mclInitializeString(25, _array174_);

static mxChar _array176_[5] = { 'B', 'l', 'a', 'c', 'k' };
static mwArray _mxarray175_ = mclInitializeString(5, _array176_);
static mwArray _mxarray177_ = mclInitializeCharVector(0, 0, (mxChar *)NULL);

void InitializeModule_Store_Parameters() {
}

void TerminateModule_Store_Parameters() {
    mxDestroyArray(_mxarray158_);
    mxDestroyArray(_mxarray141_);
    mxDestroyArray(_mxarray73_);
}

static void MStore_Parameters();

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

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

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

//
// The function "MStore_Parameters" is the implementation version of the
// "Store_Parameters" M-function from file
// "C:\shu\hier_community_exe\Store_Parameters.m" (lines 1-503). 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 Store_Parameters
//
static void MStore_Parameters() {
    mwLocalFunctionTable save_local_function_table_
      (&_local_function_table_Store_Parameters);
    mwArray j(mclGetUninitializedArray());
    mwArray errordlg_str(mclGetUninitializedArray());
    mwArray variables(mclGetUninitializedArray());
    mwArray arg_pos(mclGetUninitializedArray());
    mwArray arg(mclGetUninitializedArray());
    mwArray L(mclGetUninitializedArray());
    mwArray var(mclGetUninitializedArray());
    mwArray num_value(mclGetUninitializedArray());
    mwArray ans(mclGetUninitializedArray());
    mwArray ERROR(mclGetUninitializedArray());
    mwArray Pvar(mclGetUninitializedArray());
    mwArray i(mclGetUninitializedArray());
    mwArray num_populations(mclGetUninitializedArray());
    mwArray current_population(mclGetUninitializedArray());
    mwArray value(mclGetUninitializedArray());
    mwArray parameters(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 number_of_populations_handle(mclGetUninitializedArray());
    mwArray populations_handle(mclGetUninitializedArray());
    mwArray status_bar_handle(mclGetUninitializedArray());
    mwArray multiple_population_handle(mclGetUninitializedArray());
    //
    // 
    // multiple_population_handle = findobj('Tag','Fig_multiple_population');
    //
    multiple_population_handle = findobj(mwVarargin(_mxarray4_, _mxarray6_));
    //
    // status_bar_handle = findobj(multiple_population_handle,'Tag','StaticText_status_bar');
    //
    status_bar_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_));
    //
    // 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_,
            _mxarray12_));
    //
    // 
    // maximum_time_handle = findobj(multiple_population_handle,'Tag','EditText_maximum_time');
    //
    maximum_time_handle
      = findobj(
          mwVarargin(
            mwVv(multiple_population_handle, "multiple_population_handle"),
            _mxarray4_,
            _mxarray14_));
    //
    // 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_,
            _mxarray16_));
    //
    // maximum_x_handle = findobj(multiple_population_handle,'Tag','EditText_maximum_x');
    //
    maximum_x_handle
      = findobj(
          mwVarargin(
            mwVv(multiple_population_handle, "multiple_population_handle"),
            _mxarray4_,
            _mxarray18_));
    //
    // maximum_time_handle = findobj(multiple_population_handle,'Tag','EditText_maximum_time');
    //
    maximum_time_handle
      = findobj(
          mwVarargin(
            mwVv(multiple_population_handle, "multiple_population_handle"),
            _mxarray4_,
            _mxarray14_));
    //
    // 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_,
            _mxarray20_));
    //
    // uo_handle = findobj(multiple_population_handle,'Tag','EditText_uo');
    //
    uo_handle
      = findobj(
          mwVarargin(
            mwVv(multiple_population_handle, "multiple_population_handle"),
            _mxarray4_,
            _mxarray22_));
    //
    // growth_rate_handle = findobj(multiple_population_handle,'Tag','EditText_growth_rate');
    //
    growth_rate_handle
      = findobj(
          mwVarargin(
            mwVv(multiple_population_handle, "multiple_population_handle"),
            _mxarray4_,
            _mxarray24_));
    //
    // morality_rate_handle = findobj(multiple_population_handle,'Tag','EditText_morality_rate');
    //
    morality_rate_handle
      = findobj(
          mwVarargin(
            mwVv(multiple_population_handle, "multiple_population_handle"),
            _mxarray4_,
            _mxarray26_));
    //
    // reproduction_rate_handle = findobj(multiple_population_handle,'Tag','EditText_reproduction_rate');
    //
    reproduction_rate_handle
      = findobj(
          mwVarargin(
            mwVv(multiple_population_handle, "multiple_population_handle"),
            _mxarray4_,
            _mxarray28_));
    //
    // inflow_handle = findobj(multiple_population_handle,'Tag','EditText_inflow');
    //
    inflow_handle
      = findobj(
          mwVarargin(
            mwVv(multiple_population_handle, "multiple_population_handle"),
            _mxarray4_,
            _mxarray30_));
    //
    // weighing_function_handle = findobj(multiple_population_handle,'Tag','EditText_weighing_function');
    //
    weighing_function_handle
      = findobj(
          mwVarargin(
            mwVv(multiple_population_handle, "multiple_population_handle"),
            _mxarray4_,
            _mxarray32_));
    //
    // probability_handle=findobj(multiple_population_handle,'Tag','EditText_Probability');
    //
    probability_handle
      = findobj(
          mwVarargin(
            mwVv(multiple_population_handle, "multiple_population_handle"),
            _mxarray4_,
            _mxarray34_));
    //
    // 
    // parameters = get(multiple_population_handle,'UserData');
    //
    parameters
      = Nget(
          1,
          mwVarargin(
            mwVv(multiple_population_handle, "multiple_population_handle"),
            _mxarray36_));
    //
    // value = get(gcbo,'String');
    //
    value = Nget(1, mwVarargin(mwVe(Ngcbo(1, NULL)), _mxarray38_));
    //
    // current_population =get(populations_handle,'Value');
    //
    current_population
      = Nget(
          1,
          mwVarargin(
            mwVv(populations_handle, "populations_handle"), _mxarray40_));
    //
    // 
    // num_populations = str2num(get(number_of_populations_handle,'String'));
    //
    num_populations
      = str2num(
          mwVe(
            Nget(
              1,
              mwVarargin(
                mwVv(
                  number_of_populations_handle,
                  "number_of_populations_handle"),
                _mxarray38_))));
    //
    // for i = 1:num_populations
    //
    {
        int v_(mclForIntStart(1));
        int e_(mclForIntEnd(mwVv(num_populations, "num_populations")));
        if (v_ > e_) {
            i = _mxarray42_;
        } else {
            //
            // Pvar{i} = ['P',num2str(i)];
            // end
            //
            for (; ; ) {
                Pvar.cell(v_)
                = horzcat(mwVarargin(_mxarray43_, mwVe(num2str(mwArray(v_)))));
                if (v_ == e_) {
                    break;
                }
                ++v_;
            }
            i = v_;
        }
    }
    //
    // 
    // ERROR=0;
    //
    ERROR = _mxarray45_;
    //
    // 
    // switch gcbo
    //
    {
        mwArray v_(mwVe(Ngcbo(1, NULL)));
        if (switchcompare(v_, mwVv(probability_handle, "probability_handle"))) {
            //
            // 
            // case probability_handle
            // 
            // if(isempty(value))
            //
            if (tobool(mwVe(isempty(mwVv(value, "value"))))) {
                //
                // set(errordlg('The probability must be between 0 and 1!'),'Color','Red');
                //
                ans.EqAns(
                  Nset(
                    0,
                    mwVarargin(
                      mwVe(Nerrordlg(0, mwValueVarargout(), _mxarray46_)),
                      _mxarray48_,
                      _mxarray50_)));
                //
                // ERROR = 1;
                //
                ERROR = _mxarray52_;
            //
            // else
            //
            } else {
                //
                // num_value=str2num(value);
                //
                num_value = str2num(mwVv(value, "value"));
                //
                // if(all(num_value>=0 & num_value<=1))
                //
                if (tobool(
                      mwVe(
                        all(
                          mwVv(num_value, "num_value") >= _mxarray45_
                          & mwVv(num_value, "num_value") <= _mxarray52_)))) {
                    //
                    // parameters{3}(current_population) = setfield(parameters{3}(current_population),'gam',value);
                    //
                    parameters.cell(_mxarray53_)(
                      mwVsv(current_population, "current_population"))
                    = feval(
                        mwValueVarargout(),
                        mlxSetfield,
                        mwVarargin(
                          mwVe(
                            mwVsv(parameters, "parameters").cell(_mxarray53_)(
                              mwVsv(
                                current_population, "current_population"))),
                          _mxarray54_,
                          mwVv(value, "value")));
                //
                // else
                //
                } else {
                    //
                    // set(errordlg('The probability must be between 0 and 1!'),'Color','Red');
                    //
                    ans.EqAns(
                      Nset(
                        0,
                        mwVarargin(
                          mwVe(Nerrordlg(0, mwValueVarargout(), _mxarray46_)),
                          _mxarray48_,
                          _mxarray50_)));
                    //
                    // ERROR = 2;
                    //
                    ERROR = _mxarray56_;
                //
                // end
                //
                }
            //
            // end
            //
            }
        //
        // 
        // case maximum_time_handle
        //
        } else if (switchcompare(
                     v_, mwVv(maximum_time_handle, "maximum_time_handle"))) {
            //
            // 
            // if(isempty(value))
            //
            if (tobool(mwVe(isempty(mwVv(value, "value"))))) {
                //
                // set(errordlg('The maximum time must be a positive number!'),'Color','Red');
                //
                ans.EqAns(
                  Nset(
                    0,
                    mwVarargin(
                      mwVe(Nerrordlg(0, mwValueVarargout(), _mxarray57_)),
                      _mxarray48_,
                      _mxarray50_)));
                //
                // ERROR = 1;
                //
                ERROR = _mxarray52_;
            //
            // else
            //
            } else {
                //
                // value = str2num(value);
                //
                value = str2num(mwVv(value, "value"));
                //
                // if(value<=0)
                //
                if (mclLeBool(mwVv(value, "value"), _mxarray45_)) {
                    //
                    // set(errordlg('The maximum time must be a positive number!'),'Color','Red');
                    //
                    ans.EqAns(
                      Nset(
                        0,
                        mwVarargin(
                          mwVe(Nerrordlg(0, mwValueVarargout(), _mxarray57_)),
                          _mxarray48_,
                          _mxarray50_)));
                    //
                    // ERROR = 2;
                    //
                    ERROR = _mxarray56_;
                //
                // else
                //
                } else {
                    //
                    // parameters{2}(1) =value; 
                    //
                    parameters.cell(_mxarray56_)(_mxarray52_)
                    = mwVsv(value, "value");
                //
                // end
                //
                }
            //
            // end
            //
            }
        //
        // 
        // case number_of_time_steps_handle
        //
        } else if (switchcompare(
                     v_,
                     mwVv(
                       number_of_time_steps_handle,
                       "number_of_time_steps_handle"))) {
            //
            // 
            // if(isempty(value))
            //
            if (tobool(mwVe(isempty(mwVv(value, "value"))))) {
                //
                // set(errordlg('The # of time steps must be a positive integer!'),'Color','Red');
                //
                ans.EqAns(
                  Nset(
                    0,
                    mwVarargin(
                      mwVe(Nerrordlg(0, mwValueVarargout(), _mxarray59_)),
                      _mxarray48_,
                      _mxarray50_)));
                //
                // ERROR = 1;
                //
                ERROR = _mxarray52_;
            //
            // else
            //
            } else {
                //
                // value = str2num(value);
                //
                value = str2num(mwVv(value, "value"));
                //
                // if(value<=0 | mod(value,1) > 0)
                //
                {
                    mwArray a_(mwVv(value, "value") <= _mxarray45_);
                    if (tobool(a_)
                        || tobool(
                             a_
                             | mwVe(mod(mwVv(value, "value"), _mxarray52_))
                               > _mxarray45_)) {
                        //
                        // set(errordlg('The # of time steps must be a positive integer!'),'Color','Red');
                        //
                        ans.EqAns(
                          Nset(
                            0,
                            mwVarargin(
                              mwVe(
                                Nerrordlg(0, mwValueVarargout(), _mxarray59_)),
                              _mxarray48_,
                              _mxarray50_)));
                        //
                        // ERROR = 2;
                        //
                        ERROR = _mxarray56_;
                    //
                    // else
                    //
                    } else {
                        //
                        // parameters{2}(2) =value; 
                        //
                        parameters.cell(_mxarray56_)(_mxarray56_)
                        = mwVsv(value, "value");
                    }
                //
                // end
                //
                }
            //
            // end
            //
            }
        //
        // 
        // case maximum_x_handle
        //
        } else if (switchcompare(
                     v_, mwVv(maximum_x_handle, "maximum_x_handle"))) {
            //
            // 
            // if(isempty(value))
            //
            if (tobool(mwVe(isempty(mwVv(value, "value"))))) {
                //
                // set(errordlg('The maximum x must be a positive number!'),'Color','Red');
                //
                ans.EqAns(
                  Nset(
                    0,
                    mwVarargin(
                      mwVe(Nerrordlg(0, mwValueVarargout(), _mxarray61_)),
                      _mxarray48_,
                      _mxarray50_)));
                //
                // ERROR = 1;
                //
                ERROR = _mxarray52_;
            //
            // else
            //
            } else {
                //
                // value = str2num(value);
                //
                value = str2num(mwVv(value, "value"));
                //
                // if(value<=0)
                //
                if (mclLeBool(mwVv(value, "value"), _mxarray45_)) {
                    //
                    // set(errordlg('The maximum x must be a positive number!'),'Color','Red');
                    //
                    ans.EqAns(
                      Nset(
                        0,
                        mwVarargin(
                          mwVe(Nerrordlg(0, mwValueVarargout(), _mxarray61_)),
                          _mxarray48_,
                          _mxarray50_)));
                    //
                    // ERROR = 2;
                    //
                    ERROR = _mxarray56_;
                //
                // else
                //
                } else {
                    //
                    // parameters{2}(3) =value; 
                    //
                    parameters.cell(_mxarray56_)(_mxarray53_)
                    = mwVsv(value, "value");
                //
                // end
                //
                }
            //
            // end
            //
            }
        //
        // 
        // case number_of_x_intervals_handle
        //
        } else if (switchcompare(
                     v_,
                     mwVv(
                       number_of_x_intervals_handle,
                       "number_of_x_intervals_handle"))) {
            //
            // 
            // if(isempty(value))
            //
            if (tobool(mwVe(isempty(mwVv(value, "value"))))) {
                //
                // set(errordlg('The # of x divisions must be a positive integer!'),'Color','Red');
                //
                ans.EqAns(
                  Nset(
                    0,
                    mwVarargin(
                      mwVe(Nerrordlg(0, mwValueVarargout(), _mxarray63_)),
                      _mxarray48_,
                      _mxarray50_)));
                //
                // ERROR = 1;
                //
                ERROR = _mxarray52_;
            //
            // else
            //
            } else {
                //
                // value = str2num(value);
                //
                value = str2num(mwVv(value, "value"));
                //
                // if(value<=0 | mod(value,1) > 0)
                //
                {
                    mwArray a_(mwVv(value, "value") <= _mxarray45_);
                    if (tobool(a_)
                        || tobool(
                             a_
                             | mwVe(mod(mwVv(value, "value"), _mxarray52_))
                               > _mxarray45_)) {
                        //
                        // set(errordlg('The # of x divisions must be a positive integer!'),'Color','Red');
                        //
                        ans.EqAns(
                          Nset(
                            0,
                            mwVarargin(
                              mwVe(
                                Nerrordlg(0, mwValueVarargout(), _mxarray63_)),
                              _mxarray48_,
                              _mxarray50_)));
                        //
                        // ERROR = 2;
                        //
                        ERROR = _mxarray56_;
                    //
                    // else
                    //
                    } else {
                        //
                        // parameters{2}(4) =value; 
                        //
                        parameters.cell(_mxarray56_)(_mxarray65_)
                        = mwVsv(value, "value");
                    }
                //
                // end
                //
                }
            //
            // end
            //
            }
        //
        // 
        // case uo_handle
        //
        } else if (switchcompare(v_, mwVv(uo_handle, "uo_handle"))) {
            //
            // 
            // if(isempty(value))
            //
            if (tobool(mwVe(isempty(mwVv(value, "value"))))) {
                //
                // set(errordlg('The Initial Population Distribution is empty!'),'Color','Red');
                //
                ans.EqAns(
                  Nset(
                    0,
                    mwVarargin(
                      mwVe(Nerrordlg(0, mwValueVarargout(), _mxarray66_)),
                      _mxarray48_,
                      _mxarray50_)));
                //
                // ERROR = 1;
                //
                ERROR = _mxarray52_;
            //
            // else
            //
            } else {
                //
                // var = symvar(value);
                //
                var = symvar(mwVv(value, "value"));
                //
                // if(~isempty(var))
                //
                if (mclNotBool(mwVe(isempty(mwVv(var, "var"))))) {
                    //
                    // L=length(var);
                    //
                    L = mclLengthInt(mwVv(var, "var"));
                    //
                    // i = 1;
                    //
                    i = _mxarray52_;
                    //
                    // while(i<=L)
                    //
                    while (mclLeBool(mwVv(i, "i"), mwVv(L, "L"))) {
                        //
                        // if( ~strcmp(var{i},'x'))
                        //
                        if (mclNotBool(
                              mwVe(
                                feval(
                                  mwValueVarargout(),
                                  mlxStrcmp,
                                  mwVarargin(
                                    mwVe(mwVsv(var, "var").cell(mwVsv(i, "i"))),
                                    _mxarray68_))))) {
                            //
                            // ERROR = 3;
                            //
                            ERROR = _mxarray53_;
                            //
                            // i=L;
                            //
                            i = mwVsv(L, "L");
                        //
                        // end
                        //
                        }
                        //
                        // i = i+1;
                        //
                        i = mwVv(i, "i") + _mxarray52_;
                    //
                    // end
                    //
                    }
                    //
                    // 
                    // if(ERROR)
                    //
                    if (tobool(mwVv(ERROR, "ERROR"))) {
                        //
                        // set(errordlg('The Initial Population Distribution equation only depends on x!'),'Color','Red');
                        //
                        ans.EqAns(
                          Nset(
                            0,
                            mwVarargin(
                              mwVe(
                                Nerrordlg(0, mwValueVarargout(), _mxarray70_)),
                              _mxarray48_,
                              _mxarray50_)));
                    //
                    // else
                    //
                    } else {
                        //
                        // [arg,arg_pos]=Find_Var(value,{'x'});
                        //
                        arg
                        = Find_Var(
                            &arg_pos, mwVv(value, "value"), _mxarray72_);
                        //
                        // variables={'x'};
                        //
                        variables = _mxarray72_;
                        //
                        // errordlg_str = ...
                        //
                        errordlg_str = _mxarray74_;
                        //
                        // 'set(errordlg(''There is a syntax error in the Initial Population Distribution function''),''Color'',''Red'')';
                        // ERROR=My_Eval(value,errordlg_str,variables,arg,arg_pos);
                        //
                        ERROR
                          = My_Eval(
                              mwVv(value, "value"),
                              mwVv(errordlg_str, "errordlg_str"),
                              mwVv(variables, "variables"),
                              mwVv(arg, "arg"),
                              mwVv(arg_pos, "arg_pos"));
                    //
                    // end
                    //
                    }
                //
                // else
                //
                } else {
                    //
                    // try
                    //
                    try {
                        //
                        // num_value=eval(value);
                        //
                        num_value
                          = eval(mwValueVarargout(), mwVv(value, "value"));
                        //
                        // if(num_value < 0)
                        //
                        if (mclLtBool(
                              mwVv(num_value, "num_value"), _mxarray45_)) {
                            //
                            // set(errordlg('Initial Population Distribution function must be nonnegative'),'Color','Red'); 
                            //
                            ans.EqAns(
                              Nset(
                                0,
                                mwVarargin(
                                  mwVe(
                                    Nerrordlg(
                                      0, mwValueVarargout(), _mxarray76_)),
                                  _mxarray48_,
                                  _mxarray50_)));
                            //
                            // ERROR=4;
                            //
                            ERROR = _mxarray65_;
                        //
                        // end
                        //
                        }
                    //
                    // catch
                    //
                    } catch(mwException e_) {
                        //
                        // set(errordlg('There is a syntax error in the Initial Population Distribution function'),'Color','Red');
                        //
                        ans.EqAns(
                          Nset(
                            0,
                            mwVarargin(
                              mwVe(
                                Nerrordlg(0, mwValueVarargout(), _mxarray78_)),
                              _mxarray48_,
                              _mxarray50_)));
                        //
                        // ERROR=4;
                        //
                        ERROR = _mxarray65_;
                    //
                    // end
                    //
                    }
                //
                // 
                // end
                //
                }
            //
            // end
            //
            }
            //
            // 
            // if(ERROR==0)
            //
            if (mclEqBool(mwVv(ERROR, "ERROR"), _mxarray45_)) {
                //
                // parameters{3}(current_population) = setfield(parameters{3}(current_population),'uo',value);
                //
                parameters.cell(_mxarray53_)(
                  mwVsv(current_population, "current_population"))
                = feval(
                    mwValueVarargout(),
                    mlxSetfield,
                    mwVarargin(
                      mwVe(
                        mwVsv(parameters, "parameters").cell(_mxarray53_)(
                          mwVsv(current_population, "current_population"))),
                      _mxarray80_,
                      mwVv(value, "value")));
            //
            // end
            //
            }
        //
        // 
        // 
        // case growth_rate_handle
        //
        } else if (switchcompare(
                     v_, mwVv(growth_rate_handle, "growth_rate_handle"))) {
            //
            // 
            // if(isempty(value))
            //
            if (tobool(mwVe(isempty(mwVv(value, "value"))))) {
                //
                // set(errordlg('The Growth Rate is empty!'),'Color','Red');
                //
                ans.EqAns(
                  Nset(
                    0,
                    mwVarargin(
                      mwVe(Nerrordlg(0, mwValueVarargout(), _mxarray82_)),
                      _mxarray48_,
                      _mxarray50_)));
                //
                // ERROR = 1;
                //
                ERROR = _mxarray52_;
            //
            // else      
            //
            } else {
                //
                // var=symvar(value);
                //
                var = symvar(mwVv(value, "value"));
                //
                // if(~isempty(var))
                //
                if (mclNotBool(mwVe(isempty(mwVv(var, "var"))))) {
                    //
                    // 
                    // L=length(var);
                    //
                    L = mclLengthInt(mwVv(var, "var"));
                    //
                    // i = 1;
                    //
                    i = _mxarray52_;
                    //
                    // while(i<=L)
                    //
                    while (mclLeBool(mwVv(i, "i"), mwVv(L, "L"))) {
                        //
                        // if (length(var{i})<=2)
                        //
                        if (mclLeBool(
                              mwVe(
                                feval(
                                  mwValueVarargout(),
                                  mlxLength,
                                  mwVarargin(
                                    mwVe(
                                      mwVsv(var, "var").cell(mwVsv(i, "i")))))),
                              _mxarray56_)) {
                            //
                            // if(~strcmp(var{i},'x') & ~any(strcmp(var{i},Pvar)))
                            //
                            mwArray a_
                              (~ mwVe(
                                   feval(
                                     mwValueVarargout(),
                                     mlxStrcmp,
                                     mwVarargin(
                                       mwVe(
                                         mwVsv(var, "var").cell(mwVsv(i, "i"))),
                                       _mxarray68_))));
                            if (tobool(a_)
                                && tobool(
                                     a_
                                     & ~ mwVe(
                                           any(
                                             mwVe(
                                               feval(
                                                 mwValueVarargout(),
                                                 mlxStrcmp,
                                                 mwVarargin(
                                                   mwVe(
                                                     mwVsv(var, "var").cell(
                                                       mwVsv(i, "i"))),
                                                   mwVv(Pvar, "Pvar")))))))) {
                                //
                                // ERROR = 3;
                                //
                                ERROR = _mxarray53_;
                                //
                                // i=L;
                                //
                                i = mwVsv(L, "L");
                            } else {
                            }
                        //
                        // end
                        // else
                        //
                        } else {
                            //
                            // j=1;
                            //
                            j = _mxarray52_;
                            //
                            // while(j<=length(var{i}))
                            //
                            while (mclLeBool(
                                     mwVv(j, "j"),
                                     mwVe(
                                       feval(
                                         mwValueVarargout(),
                                         mlxLength,
                                         mwVarargin(
                                           mwVe(
                                             mwVsv(var, "var").cell(
                                               mwVsv(i, "i")))))))) {
                                //
                                // if(j+1<=length(var{i}))
                                //
                                if (mclLeBool(
                                      mwVv(j, "j") + _mxarray52_,
                                      mwVe(
                                        feval(
                                          mwValueVarargout(),
                                          mlxLength,
                                          mwVarargin(
                                            mwVe(
                                              mwVsv(var, "var").cell(
                                                mwVsv(i, "i")))))))) {
                                    //
                                    // if(~strcmp(var{i}(j),'x') & ~any(strcmp(var{i}(j:j+1),Pvar)))
                                    //
                                    mwArray a_
                                      (~ mwVe(
                                           feval(
                                             mwValueVarargout(),
                                             mlxStrcmp,
                                             mwVarargin(
                                               mwVe(
                                                 mwVsv(var, "var").cell(
                                                   mwVsv(i, "i"))(
                                                   mwVsv(j, "j"))),
                                               _mxarray68_))));
                                    if (tobool(a_)
                                        && tobool(
                                             a_
                                             & ~ mwVe(
                                                   any(
                                                     mwVe(
                                                       feval(
                                                         mwValueVarargout(),
                                                         mlxStrcmp,
                                                         mwVarargin(
                                                           mwVe(
                                                             mwVsv(
                                                               var,
                                                               "var").cell(
                                                               mwVsv(i, "i"))(
                                                               colon(
                                                                 mwVv(j, "j"),
                                                                 mwVv(j, "j")
                                                                 + _mxarray52_))),
                                                           mwVv(
                                                             Pvar,
                                                             "Pvar")))))))) {
                                        //
                                        // ERROR=3;
                                        //
                                        ERROR = _mxarray53_;
                                        //
                                        // i=L;
                                        //
                                        i = mwVsv(L, "L");
                                        //
                                        // j=length(var{i})+1;
                                        //
                                        j
                                          = mwVe(
                                              feval(
                                                mwValueVarargout(),
                                                mlxLength,
                                                mwVarargin(
                                                  mwVe(
                                                    mwVsv(var, "var").cell(
                                                      mwVsv(i, "i"))))))
                                            + _mxarray52_;
                                    //
                                    // else
                                    //
                                    } else {
                                        //
                                        // if (strcmp(var{i}(j),'x'))
                                        //
                                        if (tobool(
                                              mwVe(
                                                feval(
                                                  mwValueVarargout(),
                                                  mlxStrcmp,
                                                  mwVarargin(
                                                    mwVe(
                                                      mwVsv(var, "var").cell(
                                                        mwVsv(i, "i"))(
                                                        mwVsv(j, "j"))),
                                                    _mxarray68_))))) {
                                            //
                                            // j=j+1;
                                            //
                                            j = mwVv(j, "j") + _mxarray52_;
                                        //
                                        // else
                                        //
                                        } else {
                                            //
                                            // j=j+2;
                                            //
                                            j = mwVv(j, "j") + _mxarray56_;
                                        //
                                        // end
                                        //
                                        }
                                    }
                                //
                                // end
                                // else
                                //
                                } else {
                                    //
                                    // if(~strcmp(var{i}(j),'x'))
                                    //
                                    if (mclNotBool(
                                          mwVe(
                                            feval(
                                              mwValueVarargout(),
                                              mlxStrcmp,
                                              mwVarargin(
                                                mwVe(
                                                  mwVsv(var, "var").cell(
                                                    mwVsv(i, "i"))(
                                                    mwVsv(j, "j"))),
                                                _mxarray68_))))) {
                                        //
                                        // ERROR=3;
                                        //
                                        ERROR = _mxarray53_;
                                        //
                                        // i=L;
                                        //
                                        i = mwVsv(L, "L");
                                        //
                                        // j=length(var{i})+1;
                                        //
                                        j
                                          = mwVe(
                                              feval(
                                                mwValueVarargout(),
                                                mlxLength,
                                                mwVarargin(
                                                  mwVe(
                                                    mwVsv(var, "var").cell(
                                                      mwVsv(i, "i"))))))
                                            + _mxarray52_;
                                    //
                                    // end
                                    //
                                    }
                                //
                                // end
                                //
                                }
                            //
                            // end
                            //
                            }
                        //
                        // end
                        //
                        }
                        //
                        // i = i+1;
                        //
                        i = mwVv(i, "i") + _mxarray52_;
                    //
                    // end
                    //
                    }
                    //
                    // 
                    // if(ERROR)
                    //
                    if (tobool(mwVv(ERROR, "ERROR"))) {
                        //
                        // if(num_populations==1)
                        //
                        if (mclEqBool(
                              mwVv(num_populations, "num_populations"),
                              _mxarray52_)) {
                            //
                            // set(errordlg('The Growth Rate has variables of x and P1 only!'),'Color','Red');
                            //
                            ans.EqAns(
                              Nset(
                                0,
                                mwVarargin(
                                  mwVe(
                                    Nerrordlg(
                                      0, mwValueVarargout(), _mxarray84_)),
                                  _mxarray48_,
                                  _mxarray50_)));
                        //
                        // else
                        //
                        } else {
                            //
                            // if(num_populations==2)
                            //
                            if (mclEqBool(
                                  mwVv(num_populations, "num_populations"),
                                  _mxarray56_)) {
                                //
                                // set(errordlg('The Growth Rate has variables of x, P1 and P2 only!'),'Color','Red');
                                //
                                ans.EqAns(
                                  Nset(
                                    0,
                                    mwVarargin(
                                      mwVe(
                                        Nerrordlg(
                                          0, mwValueVarargout(), _mxarray86_)),
                                      _mxarray48_,
                                      _mxarray50_)));
                            //
                            // else
                            //
                            } else {
                                //
                                // set(errordlg(['The Growth Rate has variables of x, P1, P2,...P',num2str(num_populations),'only!']),'Color','Red');
                                //
                                ans.EqAns(
                                  Nset(
                                    0,
                                    mwVarargin(
                                      mwVe(
                                        Nerrordlg(
                                          0,
                                          mwValueVarargout(),
                                          horzcat(
                                            mwVarargin(
                                              _mxarray88_,
                                              mwVe(
                                                num2str(
                                                  mwVv(
                                                    num_populations,
                                                    "num_populations"))),
                                              _mxarray90_)))),
                                      _mxarray48_,
                                      _mxarray50_)));
                            //
                            // end
                            //
                            }
                        //
                        // end
                        //
                        }
                    //
                    // else
                    //
                    } else {
                        //
                        // variables=[{'x'},Pvar];
                        //
                        variables
                          = horzcat(
                              mwVarargin(_mxarray72_, mwVv(Pvar, "Pvar")));
                        //
                        // [arg,arg_pos]=Find_Var(value,variables);
                        //
                        arg
                        = Find_Var(
                            &arg_pos,
                            mwVv(value, "value"),
                            mwVv(variables, "variables"));
                        //
                        // errordlg_str = 'set(errordlg(''There is a syntax error in the Growth Rate function''),''Color'',''Red'')';
                        //
                        errordlg_str = _mxarray92_;
                        //
                        // ERROR=My_Eval(value,errordlg_str,variables,arg,arg_pos);
                        //
                        ERROR
                          = My_Eval(
                              mwVv(value, "value"),
                              mwVv(errordlg_str, "errordlg_str"),
                              mwVv(variables, "variables"),
                              mwVv(arg, "arg"),
                              mwVv(arg_pos, "arg_pos"));
                    //
                    // end
                    //
                    }
                //
                // else
                //
                } else {
                    //
                    // try
                    //
                    try {
                        //
                        // num_value=eval(value);
                        //
                        num_value
                          = eval(mwValueVarargout(), mwVv(value, "value"));
                        //
                        // if(num_value < 0)
                        //
                        if (mclLtBool(
                              mwVv(num_value, "num_value"), _mxarray45_)) {
                            //
                            // set(errordlg('Growth Rate function must be nonnegative'),'Color','Red'); 
                            //
                            ans.EqAns(
                              Nset(
                                0,
                                mwVarargin(
                                  mwVe(
                                    Nerrordlg(
                                      0, mwValueVarargout(), _mxarray94_)),
                                  _mxarray48_,
                                  _mxarray50_)));
                            //
                            // ERROR=4;
                            //
                            ERROR = _mxarray65_;
                        //
                        // end
                        //
                        }
                    //
                    // catch
                    //
                    } catch(mwException e_) {
                        //
                        // set(errordlg('There is a syntax error in the Growth Rate function'),'Color','Red');
                        //
                        ans.EqAns(
                          Nset(
                            0,
                            mwVarargin(
                              mwVe(
                                Nerrordlg(0, mwValueVarargout(), _mxarray96_)),
                              _mxarray48_,
                              _mxarray50_)));
                        //
                        // ERROR=4;
                        //
                        ERROR = _mxarray65_;
                    //
                    // end
                    //
                    }
                //
                // end
                //
                }
            //
            // end
            //
            }
            //
            // 
            // if(ERROR==0)
            //
            if (mclEqBool(mwVv(ERROR, "ERROR"), _mxarray45_)) {
                //
                // parameters{3}(current_population) = setfield(parameters{3}(current_population),'g',value); 
                //
                parameters.cell(_mxarray53_)(
                  mwVsv(current_population, "current_population"))
                = feval(
                    mwValueVarargout(),
                    mlxSetfield,
                    mwVarargin(
                      mwVe(
                        mwVsv(parameters, "parameters").cell(_mxarray53_)(
                          mwVsv(current_population, "current_population"))),
                      _mxarray98_,
                      mwVv(value, "value")));
            //
            // end
            //
            }
        //
        // 
        // case morality_rate_handle
        //
        } else if (switchcompare(
                     v_, mwVv(morality_rate_handle, "morality_rate_handle"))) {
            //
            // 
            // if(isempty(value))
            //
            if (tobool(mwVe(isempty(mwVv(value, "value"))))) {
                //
                // set(errordlg('The Mortality Rate is empty!'),'Color','Red');
                //
                ans.EqAns(
                  Nset(
                    0,
                    mwVarargin(
                      mwVe(Nerrordlg(0, mwValueVarargout(), _mxarray100_)),
                      _mxarray48_,
                      _mxarray50_)));
                //
                // ERROR = 1;
                //
                ERROR = _mxarray52_;
            //
            // else      
            //
            } else {
                //
                // var=symvar(value);
                //
                var = symvar(mwVv(value, "value"));
                //
                // if(~isempty(var))
                //
                if (mclNotBool(mwVe(isempty(mwVv(var, "var"))))) {
                    //
                    // 
                    // L=length(var);
                    //
                    L = mclLengthInt(mwVv(var, "var"));
                    //
                    // i = 1;
                    //
                    i = _mxarray52_;
                    //
                    // while(i<=L)
                    //
                    while (mclLeBool(mwVv(i, "i"), mwVv(L, "L"))) {
                        //
                        // if (length(var{i})<=2)
                        //
                        if (mclLeBool(
                              mwVe(
                                feval(
                                  mwValueVarargout(),
                                  mlxLength,
                                  mwVarargin(
                                    mwVe(
                                      mwVsv(var, "var").cell(mwVsv(i, "i")))))),
                              _mxarray56_)) {
                            //
                            // if(~strcmp(var{i},'x') & ~any(strcmp(var{i},Pvar)))
                            //
                            mwArray a_
                              (~ mwVe(
                                   feval(
                                     mwValueVarargout(),
                                     mlxStrcmp,
                                     mwVarargin(
                                       mwVe(
                                         mwVsv(var, "var").cell(mwVsv(i, "i"))),
                                       _mxarray68_))));
                            if (tobool(a_)
                                && tobool(
                                     a_
                                     & ~ mwVe(
                                           any(
                                             mwVe(
                                               feval(
                                                 mwValueVarargout(),
                                                 mlxStrcmp,
                                                 mwVarargin(
                                                   mwVe(
                                                     mwVsv(var, "var").cell(
                                                       mwVsv(i, "i"))),
                                                   mwVv(Pvar, "Pvar")))))))) {
                                //
                                // ERROR = 3;
                                //
                                ERROR = _mxarray53_;
                                //
                                // i=L;
                                //
                                i = mwVsv(L, "L");
                            } else {
                            }
                        //
                        // end
                        // else
                        //
                        } else {
                            //
                            // j=1;
                            //
                            j = _mxarray52_;
                            //
                            // while(j<=length(var{i}))
                            //
                            while (mclLeBool(
                                     mwVv(j, "j"),
                                     mwVe(
                                       feval(
                                         mwValueVarargout(),
                                         mlxLength,
                                         mwVarargin(
                                           mwVe(
                                             mwVsv(var, "var").cell(
                                               mwVsv(i, "i")))))))) {
                                //
                                // if(j+1<=length(var{i}))
                                //
                                if (mclLeBool(
                                      mwVv(j, "j") + _mxarray52_,
                                      mwVe(
                                        feval(
                                          mwValueVarargout(),
                                          mlxLength,
                                          mwVarargin(
                                            mwVe(
                                              mwVsv(var, "var").cell(
                                                mwVsv(i, "i")))))))) {
                                    //
                                    // if(~strcmp(var{i}(j),'x') & ~any(strcmp(var{i}(j:j+1),Pvar)))
                                    //
                                    mwArray a_
                                      (~ mwVe(
                                           feval(
                                             mwValueVarargout(),
                                             mlxStrcmp,
                                             mwVarargin(
                                               mwVe(
                                                 mwVsv(var, "var").cell(
                                                   mwVsv(i, "i"))(
                                                   mwVsv(j, "j"))),
                                               _mxarray68_))));
                                    if (tobool(a_)
                                        && tobool(
                                             a_
                                             & ~ mwVe(
                                                   any(
                                                     mwVe(
                                                       feval(
                                                         mwValueVarargout(),
                                                         mlxStrcmp,
                                                         mwVarargin(
                                                           mwVe(
                                                             mwVsv(
                                                               var,
                                                               "var").cell(
                                                               mwVsv(i, "i"))(
                                                               colon(
                                                                 mwVv(j, "j"),
                                                                 mwVv(j, "j")
                                                                 + _mxarray52_))),
                                                           mwVv(
                                                             Pvar,
                                                             "Pvar")))))))) {
                                        //
                                        // ERROR=3;
                                        //
                                        ERROR = _mxarray53_;
                                        //
                                        // i=L;
                                        //
                                        i = mwVsv(L, "L");
                                        //
                                        // j=length(var{i})+1;
                                        //
                                        j
                                          = mwVe(
                                              feval(
                                                mwValueVarargout(),
                                                mlxLength,
                                                mwVarargin(
                                                  mwVe(
                                                    mwVsv(var, "var").cell(
                                                      mwVsv(i, "i"))))))
                                            + _mxarray52_;
                                    //
                                    // else
                                    //
                                    } else {
                                        //
                                        // if (strcmp(var{i}(j),'x'))
                                        //
                                        if (tobool(
                                              mwVe(
                                                feval(
                                                  mwValueVarargout(),
                                                  mlxStrcmp,
                                                  mwVarargin(
                                                    mwVe(
                                                      mwVsv(var, "var").cell(
                                                        mwVsv(i, "i"))(
                                                        mwVsv(j, "j"))),
                                                    _mxarray68_))))) {
                                            //
                                            // j=j+1;
                                            //
                                            j = mwVv(j, "j") + _mxarray52_;
                                        //
                                        // else
                                        //
                                        } else {
                                            //
                                            // j=j+2;
                                            //
                                            j = mwVv(j, "j") + _mxarray56_;
                                        //
                                        // end
                                        //
                                        }
                                    }
                                //
                                // end
                                // else
                                //
                                } else {
                                    //
                                    // if(~strcmp(var{i}(j),'x'))
                                    //
                                    if (mclNotBool(
                                          mwVe(
                                            feval(
                                              mwValueVarargout(),
                                              mlxStrcmp,
                                              mwVarargin(
                                                mwVe(
                                                  mwVsv(var, "var").cell(
                                                    mwVsv(i, "i"))(
                                                    mwVsv(j, "j"))),
                                                _mxarray68_))))) {
                                        //
                                        // ERROR=3;
                                        //
                                        ERROR = _mxarray53_;
                                        //
                                        // i=L;
                                        //
                                        i = mwVsv(L, "L");
                                        //
                                        // j=length(var{i})+1;
                                        //
                                        j
                                          = mwVe(
                                              feval(
                                                mwValueVarargout(),
                                                mlxLength,
                                                mwVarargin(
                                                  mwVe(
                                                    mwVsv(var, "var").cell(
                                                      mwVsv(i, "i"))))))
                                            + _mxarray52_;
                                    //
                                    // end
                                    //
                                    }
                                //
                                // end
                                //
                                }
                            //
                            // end
                            //
                            }
                        //
                        // end
                        //
                        }
                        //
                        // i = i+1;
                        //
                        i = mwVv(i, "i") + _mxarray52_;
                    //
                    // end
                    //
                    }
                    //
                    // 
                    // if(ERROR)
                    //
                    if (tobool(mwVv(ERROR, "ERROR"))) {
                        //
                        // if(num_populations==1)
                        //
                        if (mclEqBool(
                              mwVv(num_populations, "num_populations"),
                              _mxarray52_)) {
                            //
                            // set(errordlg('The Mortality Rate has variables of x and P1 only!'),'Color','Red');
                            //
                            ans.EqAns(
                              Nset(
                                0,
                                mwVarargin(
                                  mwVe(
                                    Nerrordlg(
                                      0, mwValueVarargout(), _mxarray102_)),
                                  _mxarray48_,
                                  _mxarray50_)));
                        //
                        // else
                        //
                        } else {
                            //
                            // if(num_populations==2)
                            //
                            if (mclEqBool(
                                  mwVv(num_populations, "num_populations"),
                                  _mxarray56_)) {
                                //
                                // set(errordlg('The Mortality Rate has variables of x, P1 and P2 only!'),'Color','Red');
                                //
                                ans.EqAns(
                                  Nset(
                                    0,
                                    mwVarargin(
                                      mwVe(
                                        Nerrordlg(
                                          0, mwValueVarargout(), _mxarray104_)),
                                      _mxarray48_,
                                      _mxarray50_)));
                            //
                            // else
                            //
                            } else {
                                //
                                // set(errordlg(['The Mortality Rate has variables of x, P1, P2,...P',num2str(num_populations),' only!']),'Color','Red');
                                //
                                ans.EqAns(
                                  Nset(
                                    0,
                                    mwVarargin(
                                      mwVe(
                                        Nerrordlg(
                                          0,
                                          mwValueVarargout(),
                                          horzcat(
                                            mwVarargin(
                                              _mxarray106_,
                                              mwVe(
                                                num2str(
                                                  mwVv(
                                                    num_populations,
                                                    "num_populations"))),
                                              _mxarray108_)))),
                                      _mxarray48_,
                                      _mxarray50_)));
                            //
                            // end
                            //
                            }
                        //
                        // end
                        //
                        }
                    //
                    // else
                    //
                    } else {
                        //
                        // variables=[{'x'},Pvar];
                        //
                        variables
                          = horzcat(
                              mwVarargin(_mxarray72_, mwVv(Pvar, "Pvar")));
                        //
                        // [arg,arg_pos]=Find_Var(value,variables); 
                        //
                        arg
                        = Find_Var(
                            &arg_pos,
                            mwVv(value, "value"),
                            mwVv(variables, "variables"));
                        //
                        // errordlg_str = 'set(errordlg(''There is a syntax error in the Mortality Rate function''),''Color'',''Red'')';
                        //
                        errordlg_str = _mxarray110_;
                        //
                        // ERROR=My_Eval(value,errordlg_str,variables,arg,arg_pos);
                        //
                        ERROR
                          = My_Eval(
                              mwVv(value, "value"),
                              mwVv(errordlg_str, "errordlg_str"),
                              mwVv(variables, "variables"),
                              mwVv(arg, "arg"),
                              mwVv(arg_pos, "arg_pos"));
                    //
                    // end
                    //
                    }
                //
                // else
                //
                } else {
                    //
                    // try
                    //
                    try {
                        //
                        // num_value=eval(value);
                        //
                        num_value
                          = eval(mwValueVarargout(), mwVv(value, "value"));
                        //
                        // if(num_value < 0)
                        //
                        if (mclLtBool(
                              mwVv(num_value, "num_value"), _mxarray45_)) {
                            //
                            // set(errordlg('Mortality Rate function must be nonnegative'),'Color','Red'); 
                            //
                            ans.EqAns(
                              Nset(
                                0,
                                mwVarargin(
                                  mwVe(
                                    Nerrordlg(
                                      0, mwValueVarargout(), _mxarray112_)),
                                  _mxarray48_,
                                  _mxarray50_)));
                            //
                            // ERROR=4;
                            //
                            ERROR = _mxarray65_;
                        //
                        // end
                        //
                        }
                    //
                    // catch
                    //
                    } catch(mwException e_) {
                        //
                        // set(errordlg('There is a syntax error in the Mortality Rate function'),'Color','Red');
                        //
                        ans.EqAns(
                          Nset(
                            0,
                            mwVarargin(
                              mwVe(
                                Nerrordlg(0, mwValueVarargout(), _mxarray114_)),
                              _mxarray48_,
                              _mxarray50_)));
                        //
                        // ERROR=4;
                        //
                        ERROR = _mxarray65_;
                    //
                    // end
                    //
                    }
                //
                // 
                // end
                //
                }
            //
            // end
            //
            }
            //
            // 
            // if (ERROR==0)
            //
            if (mclEqBool(mwVv(ERROR, "ERROR"), _mxarray45_)) {
                //
                // parameters{3}(current_population) = setfield(parameters{3}(current_population),'m',value);  
                //
                parameters.cell(_mxarray53_)(
                  mwVsv(current_population, "current_population"))
                = feval(
                    mwValueVarargout(),
                    mlxSetfield,
                    mwVarargin(
                      mwVe(
                        mwVsv(parameters, "parameters").cell(_mxarray53_)(
                          mwVsv(current_population, "current_population"))),
                      _mxarray116_,
                      mwVv(value, "value")));
            //
            // end
            //
            }
        //
        // 
        // case reproduction_rate_handle
        //
        } else if (switchcompare(
                     v_,
                     mwVv(
                       reproduction_rate_handle, "reproduction_rate_handle"))) {
            //
            // 
            // if(isempty(value))
            //
            if (tobool(mwVe(isempty(mwVv(value, "value"))))) {
                //
                // set(errordlg('The Reprodcution Rate is empty!'),'Color','Red');
                //
                ans.EqAns(
                  Nset(
                    0,
                    mwVarargin(
                      mwVe(Nerrordlg(0, mwValueVarargout(), _mxarray118_)),
                      _mxarray48_,
                      _mxarray50_)));
                //
                // ERROR = 1;
                //
                ERROR = _mxarray52_;
            //
            // else      
            //
            } else {
                //
                // var=symvar(value);
                //
                var = symvar(mwVv(value, "value"));
                //
                // if(~isempty(var))
                //
                if (mclNotBool(mwVe(isempty(mwVv(var, "var"))))) {
                    //
                    // 
                    // L=length(var);
                    //
                    L = mclLengthInt(mwVv(var, "var"));
                    //
                    // i = 1;
                    //
                    i = _mxarray52_;
                    //
                    // while(i<=L)
                    //
                    while (mclLeBool(mwVv(i, "i"), mwVv(L, "L"))) {
                        //
                        // if (length(var{i})<=2)
                        //
                        if (mclLeBool(
                              mwVe(
                                feval(
                                  mwValueVarargout(),
                                  mlxLength,
                                  mwVarargin(
                                    mwVe(
                                      mwVsv(var, "var").cell(mwVsv(i, "i")))))),
                              _mxarray56_)) {
                            //
                            // if(~strcmp(var{i},'x') & ~any(strcmp(var{i},Pvar)))
                            //
                            mwArray a_
                              (~ mwVe(
                                   feval(
                                     mwValueVarargout(),
                                     mlxStrcmp,
                                     mwVarargin(
                                       mwVe(
                                         mwVsv(var, "var").cell(mwVsv(i, "i"))),
                                       _mxarray68_))));
                            if (tobool(a_)
                                && tobool(
                                     a_
                                     & ~ mwVe(
                                           any(
                                             mwVe(
                                               feval(
                                                 mwValueVarargout(),
                                                 mlxStrcmp,
                                                 mwVarargin(
                                                   mwVe(
                                                     mwVsv(var, "var").cell(
                                                       mwVsv(i, "i"))),
                                                   mwVv(Pvar, "Pvar")))))))) {
                                //
                                // ERROR = 3;
                                //
                                ERROR = _mxarray53_;
                                //
                                // i=L;
                                //
                                i = mwVsv(L, "L");
                            } else {
                            }
                        //
                        // end
                        // else
                        //
                        } else {
                            //
                            // j=1;
                            //
                            j = _mxarray52_;
                            //
                            // while(j<=length(var{i}))
                            //
                            while (mclLeBool(
                                     mwVv(j, "j"),
                                     mwVe(
                                       feval(
                                         mwValueVarargout(),
                                         mlxLength,
                                         mwVarargin(
                                           mwVe(
                                             mwVsv(var, "var").cell(
                                               mwVsv(i, "i")))))))) {
                                //
                                // if(j+1<=length(var{i}))
                                //
                                if (mclLeBool(
                                      mwVv(j, "j") + _mxarray52_,
                                      mwVe(
                                        feval(
                                          mwValueVarargout(),
                                          mlxLength,
                                          mwVarargin(
                                            mwVe(
                                              mwVsv(var, "var").cell(
                                                mwVsv(i, "i")))))))) {
                                    //
                                    // if(~strcmp(var{i}(j),'x') & ~any(strcmp(var{i}(j:j+1),Pvar)))
                                    //
                                    mwArray a_
                                      (~ mwVe(
                                           feval(
                                             mwValueVarargout(),
                                             mlxStrcmp,
                                             mwVarargin(
                                               mwVe(
                                                 mwVsv(var, "var").cell(
                                                   mwVsv(i, "i"))(
                                                   mwVsv(j, "j"))),
                                               _mxarray68_))));
                                    if (tobool(a_)
                                        && tobool(
                                             a_
                                             & ~ mwVe(
                                                   any(
                                                     mwVe(
                                                       feval(
                                                         mwValueVarargout(),
                                                         mlxStrcmp,
                                                         mwVarargin(
                                                           mwVe(
                                                             mwVsv(
                                                               var,
                                                               "var").cell(
                                                               mwVsv(i, "i"))(
                                                               colon(
                                                                 mwVv(j, "j"),
                                                                 mwVv(j, "j")
                                                                 + _mxarray52_))),
                                                           mwVv(
                                                             Pvar,
                                                             "Pvar")))))))) {
                                        //
                                        // ERROR=3;
                                        //
                                        ERROR = _mxarray53_;
                                        //
                                        // i=L;
                                        //
                                        i = mwVsv(L, "L");
                                        //
                                        // j=length(var{i})+1;
                                        //
                                        j
                                          = mwVe(
                                              feval(
                                                mwValueVarargout(),
                                                mlxLength,
                                                mwVarargin(
                                                  mwVe(
                                                    mwVsv(var, "var").cell(
                                                      mwVsv(i, "i"))))))
                                            + _mxarray52_;
                                    //
                                    // else
                                    //
                                    } else {
                                        //
                                        // if (strcmp(var{i}(j),'x'))
                                        //
                                        if (tobool(
                                              mwVe(
                                                feval(
                                                  mwValueVarargout(),
                                                  mlxStrcmp,
                                                  mwVarargin(
                                                    mwVe(
                                                      mwVsv(var, "var").cell(
                                                        mwVsv(i, "i"))(
                                                        mwVsv(j, "j"))),
                                                    _mxarray68_))))) {
                                            //
                                            // j=j+1;
                                            //
                                            j = mwVv(j, "j") + _mxarray52_;
                                        //
                                        // else
                                        //
                                        } else {
                                            //
                                            // j=j+2;
                                            //
                                            j = mwVv(j, "j") + _mxarray56_;
                                        //
                                        // end
                                        //
                                        }
                                    }
                                //
                                // end
                                // else
                                //
                                } else {
                                    //
                                    // if(~strcmp(var{i}(j),'x'))
                                    //
                                    if (mclNotBool(
                                          mwVe(
                                            feval(
                                              mwValueVarargout(),
                                              mlxStrcmp,
                                              mwVarargin(
                                                mwVe(
                                                  mwVsv(var, "var").cell(
                                                    mwVsv(i, "i"))(
                                                    mwVsv(j, "j"))),
                                                _mxarray68_))))) {
                                        //
                                        // ERROR=3;
                                        //
                                        ERROR = _mxarray53_;
                                        //
                                        // i=L;
                                        //
                                        i = mwVsv(L, "L");
                                        //
                                        // j=length(var{i})+1;
                                        //
                                        j
                                          = mwVe(
                                              feval(
                                                mwValueVarargout(),
                                                mlxLength,
                                                mwVarargin(
                                                  mwVe(
                                                    mwVsv(var, "var").cell(
                                                      mwVsv(i, "i"))))))
                                            + _mxarray52_;
                                    //
                                    // end
                                    //
                                    }
                                //
                                // end
                                //
                                }
                            //
                            // end
                            //
                            }
                        //
                        // end
                        //
                        }
                        //
                        // i = i+1;
                        //
                        i = mwVv(i, "i") + _mxarray52_;
                    //
                    // end
                    //
                    }
                    //
                    // 
                    // if(ERROR)
                    //
                    if (tobool(mwVv(ERROR, "ERROR"))) {
                        //
                        // if(num_populations==1)
                        //
                        if (mclEqBool(
                              mwVv(num_populations, "num_populations"),
                              _mxarray52_)) {
                            //
                            // set(errordlg('The Reproduction Rate has variables of x and P1 only!'),'Color','Red');
                            //
                            ans.EqAns(
                              Nset(
                                0,
                                mwVarargin(
                                  mwVe(
                                    Nerrordlg(
                                      0, mwValueVarargout(), _mxarray120_)),
                                  _mxarray48_,
                                  _mxarray50_)));
                        //
                        // else
                        //
                        } else {
                            //
                            // if(num_populations==2)
                            //
                            if (mclEqBool(
                                  mwVv(num_populations, "num_populations"),
                                  _mxarray56_)) {
                                //
                                // set(errordlg('The Reproduction Rate has variables of x, P1 and P2 only!'),'Color','Red');
                                //
                                ans.EqAns(
                                  Nset(
                                    0,
                                    mwVarargin(
                                      mwVe(
                                        Nerrordlg(
                                          0, mwValueVarargout(), _mxarray122_)),
                                      _mxarray48_,
                                      _mxarray50_)));
                            //
                            // else
                            //
                            } else {
                                //
                                // set(errordlg(['The Reproduction Rate has variables of x, P1, P2,...P',num2str(num_populations),' only!']),'Color','Red');
                                //
                                ans.EqAns(
                                  Nset(
                                    0,
                                    mwVarargin(
                                      mwVe(
                                        Nerrordlg(
                                          0,
                                          mwValueVarargout(),
                                          horzcat(
                                            mwVarargin(
                                              _mxarray124_,
                                              mwVe(
                                                num2str(
                                                  mwVv(
                                                    num_populations,
                                                    "num_populations"))),
                                              _mxarray108_)))),
                                      _mxarray48_,
                                      _mxarray50_)));
                            //
                            // end
                            //
                            }
                        //
                        // end
                        //
                        }
                    //
                    // else
                    //
                    } else {
                        //
                        // variables=[{'x'},Pvar];
                        //
                        variables
                          = horzcat(
                              mwVarargin(_mxarray72_, mwVv(Pvar, "Pvar")));
                        //
                        // [arg,arg_pos]=Find_Var(value,variables); 
                        //
                        arg
                        = Find_Var(
                            &arg_pos,
                            mwVv(value, "value"),
                            mwVv(variables, "variables"));
                        //
                        // errordlg_str = 'set(errordlg(''There is a syntax error in the Reproduction Rate function''),''Color'',''Red'')';
                        //
                        errordlg_str = _mxarray126_;
                        //
                        // ERROR=My_Eval(value,errordlg_str,variables,arg,arg_pos);
                        //
                        ERROR
                          = My_Eval(
                              mwVv(value, "value"),
                              mwVv(errordlg_str, "errordlg_str"),
                              mwVv(variables, "variables"),
                              mwVv(arg, "arg"),
                              mwVv(arg_pos, "arg_pos"));
                    //
                    // end
                    //
                    }
                //
                // else
                //
                } else {
                    //
                    // try
                    //
                    try {
                        //
                        // num_value=eval(value);
                        //
                        num_value
                          = eval(mwValueVarargout(), mwVv(value, "value"));
                        //
                        // if(num_value < 0)
                        //
                        if (mclLtBool(
                              mwVv(num_value, "num_value"), _mxarray45_)) {
                            //
                            // set(errordlg('Reproduction Rate function must be nonnegative'),'Color','Red'); 
                            //
                            ans.EqAns(
                              Nset(
                                0,
                                mwVarargin(
                                  mwVe(
                                    Nerrordlg(
                                      0, mwValueVarargout(), _mxarray128_)),
                                  _mxarray48_,
                                  _mxarray50_)));
                            //
                            // ERROR=4;
                            //
                            ERROR = _mxarray65_;
                        //
                        // end
                        //
                        }
                    //
                    // catch
                    //
                    } catch(mwException e_) {
                        //
                        // set(errordlg('There is a syntax error in the Reproduction Rate function'),'Color','Red');
                        //
                        ans.EqAns(
                          Nset(
                            0,
                            mwVarargin(
                              mwVe(
                                Nerrordlg(0, mwValueVarargout(), _mxarray130_)),
                              _mxarray48_,
                              _mxarray50_)));
                        //
                        // ERROR=4;
                        //
                        ERROR = _mxarray65_;
                    //
                    // end
                    //
                    }
                //
                // 
                // end
                //
                }
            //
            // end
            //
            }
            //
            // 
            // if(ERROR==0)
            //
            if (mclEqBool(mwVv(ERROR, "ERROR"), _mxarray45_)) {
                //
                // parameters{3}(current_population) = setfield(parameters{3}(current_population),'b',value);
                //
                parameters.cell(_mxarray53_)(
                  mwVsv(current_population, "current_population"))
                = feval(
                    mwValueVarargout(),
                    mlxSetfield,
                    mwVarargin(
                      mwVe(
                        mwVsv(parameters, "parameters").cell(_mxarray53_)(
                          mwVsv(current_population, "current_population"))),
                      _mxarray132_,
                      mwVv(value, "value")));
            //
            // end
            //
            }
        //
        // 
        // 
        // case inflow_handle
        //
        } else if (switchcompare(v_, mwVv(inflow_handle, "inflow_handle"))) {
            //
            // 
            // if (isempty(value))
            //
            if (tobool(mwVe(isempty(mwVv(value, "value"))))) {
                //
                // set(errordlg('The Inflow of Zero-Sized is empty!'),'Color','Red');
                //
                ans.EqAns(
                  Nset(
                    0,
                    mwVarargin(
                      mwVe(Nerrordlg(0, mwValueVarargout(), _mxarray134_)),
                      _mxarray48_,
                      _mxarray50_)));
                //
                // ERROR = 1;
                //
                ERROR = _mxarray52_;
            //
            // else
            //
            } else {
                //
                // var = symvar(value);
                //
                var = symvar(mwVv(value, "value"));
                //
                // if (~isempty(var))
                //
                if (mclNotBool(mwVe(isempty(mwVv(var, "var"))))) {
                    //
                    // L=length(var);
                    //
                    L = mclLengthInt(mwVv(var, "var"));
                    //
                    // i = 1;
                    //
                    i = _mxarray52_;
                    //
                    // while(i<=L)
                    //
                    while (mclLeBool(mwVv(i, "i"), mwVv(L, "L"))) {
                        //
                        // if( ~strcmp(var{i},'t'))
                        //
                        if (mclNotBool(
                              mwVe(
                                feval(
                                  mwValueVarargout(),
                                  mlxStrcmp,
                                  mwVarargin(
                                    mwVe(mwVsv(var, "var").cell(mwVsv(i, "i"))),
                                    _mxarray136_))))) {
                            //
                            // ERROR = 3;
                            //
                            ERROR = _mxarray53_;
                            //
                            // i=L;
                            //
                            i = mwVsv(L, "L");
                        //
                        // end
                        //
                        }
                        //
                        // i = i+1;
                        //
                        i = mwVv(i, "i") + _mxarray52_;
                    //
                    // end
                    //
                    }
                    //
                    // 
                    // if(ERROR)
                    //
                    if (tobool(mwVv(ERROR, "ERROR"))) {
                        //
                        // set(errordlg('The Inflow of Zero-Sized equation only depends on t!'),'Color','Red');
                        //
                        ans.EqAns(
                          Nset(
                            0,
                            mwVarargin(
                              mwVe(
                                Nerrordlg(0, mwValueVarargout(), _mxarray138_)),
                              _mxarray48_,
                              _mxarray50_)));
                    //
                    // else
                    //
                    } else {
                        //
                        // variables={'t'};
                        //
                        variables = _mxarray140_;
                        //
                        // [arg,arg_pos]=Find_Var(value,variables); 
                        //
                        arg
                        = Find_Var(
                            &arg_pos,
                            mwVv(value, "value"),
                            mwVv(variables, "variables"));
                        //
                        // errordlg_str = ...
                        //
                        errordlg_str = _mxarray142_;
                        //
                        // 'set(errordlg(''There is a syntax error in the Inflow of Zero-Sized equation''),''Color'',''Red'')';
                        // ERROR=My_Eval(value,errordlg_str,variables,arg,arg_pos);
                        //
                        ERROR
                          = My_Eval(
                              mwVv(value, "value"),
                              mwVv(errordlg_str, "errordlg_str"),
                              mwVv(variables, "variables"),
                              mwVv(arg, "arg"),
                              mwVv(arg_pos, "arg_pos"));
                    //
                    // end
                    //
                    }
                //
                // else
                //
                } else {
                    //
                    // try
                    //
                    try {
                        //
                        // num_value=eval(value);
                        //
                        num_value
                          = eval(mwValueVarargout(), mwVv(value, "value"));
                        //
                        // if(num_value < 0)
                        //
                        if (mclLtBool(
                              mwVv(num_value, "num_value"), _mxarray45_)) {
                            //
                            // set(errordlg('Inflow of Zero-Sized function must be nonnegative'),'Color','Red'); 
                            //
                            ans.EqAns(
                              Nset(
                                0,
                                mwVarargin(
                                  mwVe(
                                    Nerrordlg(
                                      0, mwValueVarargout(), _mxarray144_)),
                                  _mxarray48_,
                                  _mxarray50_)));
                            //
                            // ERROR=4;
                            //
                            ERROR = _mxarray65_;
                        //
                        // end
                        //
                        }
                    //
                    // catch
                    //
                    } catch(mwException e_) {
                        //
                        // set(errordlg('There is a syntax error in the Inflow of Zero-Sized function'),'Color','Red');
                        //
                        ans.EqAns(
                          Nset(
                            0,
                            mwVarargin(
                              mwVe(
                                Nerrordlg(0, mwValueVarargout(), _mxarray146_)),
                              _mxarray48_,
                              _mxarray50_)));
                        //
                        // ERROR=4;
                        //
                        ERROR = _mxarray65_;
                    //
                    // end
                    //
                    }
                //
                // 
                // end
                //
                }
            //
            // end
            //
            }
            //
            // 
            // if(ERROR==0)
            //
            if (mclEqBool(mwVv(ERROR, "ERROR"), _mxarray45_)) {
                //
                // parameters{3}(current_population) = setfield(parameters{3}(current_population),'c',value);
                //
                parameters.cell(_mxarray53_)(
                  mwVsv(current_population, "current_population"))
                = feval(
                    mwValueVarargout(),
                    mlxSetfield,
                    mwVarargin(
                      mwVe(
                        mwVsv(parameters, "parameters").cell(_mxarray53_)(
                          mwVsv(current_population, "current_population"))),
                      _mxarray148_,
                      mwVv(value, "value")));
            //
            // end
            //
            }
        //
        // 
        // 
        // case weighing_function_handle
        //
        } else if (switchcompare(
                     v_,
                     mwVv(
                       weighing_function_handle, "weighing_function_handle"))) {
            //
            // if (isempty(value))
            //
            if (tobool(mwVe(isempty(mwVv(value, "value"))))) {
                //
                // set(errordlg('The Weighting Function is empty!'),'Color','Red');
                //
                ans.EqAns(
                  Nset(
                    0,
                    mwVarargin(
                      mwVe(Nerrordlg(0, mwValueVarargout(), _mxarray150_)),
                      _mxarray48_,
                      _mxarray50_)));
                //
                // ERROR = 1;
                //
                ERROR = _mxarray52_;
            //
            // else
            //
            } else {
                //
                // var = symvar(value);
                //
                var = symvar(mwVv(value, "value"));
                //
                // if (~isempty(var))
                //
                if (mclNotBool(mwVe(isempty(mwVv(var, "var"))))) {
                    //
                    // L=length(var);
                    //
                    L = mclLengthInt(mwVv(var, "var"));
                    //
                    // i = 1;
                    //
                    i = _mxarray52_;
                    //
                    // while(i<=L)
                    //
                    while (mclLeBool(mwVv(i, "i"), mwVv(L, "L"))) {
                        //
                        // if( ~strcmp(var{i},'y') & ~strcmp(var{i},'x'))
                        //
                        mwArray a_
                          (~ mwVe(
                               feval(
                                 mwValueVarargout(),
                                 mlxStrcmp,
                                 mwVarargin(
                                   mwVe(mwVsv(var, "var").cell(mwVsv(i, "i"))),
                                   _mxarray152_))));
                        if (tobool(a_)
                            && tobool(
                                 a_
                                 & ~ mwVe(
                                       feval(
                                         mwValueVarargout(),
                                         mlxStrcmp,
                                         mwVarargin(
                                           mwVe(
                                             mwVsv(var, "var").cell(
                                               mwVsv(i, "i"))),
                                           _mxarray68_))))) {
                            //
                            // ERROR = 3;
                            //
                            ERROR = _mxarray53_;
                            //
                            // i=L;
                            //
                            i = mwVsv(L, "L");
                        } else {
                        }
                        //
                        // end
                        // i = i+1;
                        //
                        i = mwVv(i, "i") + _mxarray52_;
                    //
                    // end
                    //
                    }
                    //
                    // 
                    // if(ERROR)
                    //
                    if (tobool(mwVv(ERROR, "ERROR"))) {
                        //
                        // set(errordlg('The Weighting Function depends on x and y only!'),'Color','Red');
                        //
                        ans.EqAns(
                          Nset(
                            0,
                            mwVarargin(
                              mwVe(
                                Nerrordlg(0, mwValueVarargout(), _mxarray154_)),
                              _mxarray48_,
                              _mxarray50_)));
                    //
                    // else
                    //
                    } else {
                        //
                        // variables=[{'x'},{'y'}];
                        //
                        variables = _mxarray156_;
                        //
                        // [arg,arg_pos]=Find_Var(value,variables); 
                        //
                        arg
                        = Find_Var(
                            &arg_pos,
                            mwVv(value, "value"),
                            mwVv(variables, "variables"));
                        //
                        // errordlg_str = ...
                        //
                        errordlg_str = _mxarray159_;
                        //
                        // 'set(errordlg(''There is a syntax error in the Weighting Function''),''Color'',''Red'')';
                        // ERROR=My_Eval(value,errordlg_str,variables,arg,arg_pos);
                        //
                        ERROR
                          = My_Eval(
                              mwVv(value, "value"),
                              mwVv(errordlg_str, "errordlg_str"),
                              mwVv(variables, "variables"),
                              mwVv(arg, "arg"),
                              mwVv(arg_pos, "arg_pos"));
                    //
                    // end
                    //
                    }
                //
                // else
                //
                } else {
                    //
                    // try
                    //
                    try {
                        //
                        // num_value=eval(value);
                        //
                        num_value
                          = eval(mwValueVarargout(), mwVv(value, "value"));
                        //
                        // if(num_value < 0)
                        //
                        if (mclLtBool(
                              mwVv(num_value, "num_value"), _mxarray45_)) {
                            //
                            // set(errordlg('Weighing function must be nonnegative'),'Color','Red'); 
                            //
                            ans.EqAns(
                              Nset(
                                0,
                                mwVarargin(
                                  mwVe(
                                    Nerrordlg(
                                      0, mwValueVarargout(), _mxarray161_)),
                                  _mxarray48_,
                                  _mxarray50_)));
                            //
                            // ERROR=4;
                            //
                            ERROR = _mxarray65_;
                        //
                        // end
                        //
                        }
                    //
                    // catch
                    //
                    } catch(mwException e_) {
                        //
                        // set(errordlg('There is a syntax error in the Weighting Function'),'Color','Red');
                        //
                        ans.EqAns(
                          Nset(
                            0,
                            mwVarargin(
                              mwVe(
                                Nerrordlg(0, mwValueVarargout(), _mxarray163_)),
                              _mxarray48_,
                              _mxarray50_)));
                        //
                        // ERROR=4;
                        //
                        ERROR = _mxarray65_;
                    //
                    // end
                    //
                    }
                //
                // 
                // end
                //
                }
            //
            // end
            //
            }
            //
            // if(ERROR==0)
            //
            if (mclEqBool(mwVv(ERROR, "ERROR"), _mxarray45_)) {
                //
                // parameters{3}(current_population) = setfield(parameters{3}(current_population),'w',value); 
                //
                parameters.cell(_mxarray53_)(
                  mwVsv(current_population, "current_population"))
                = feval(
                    mwValueVarargout(),
                    mlxSetfield,
                    mwVarargin(
                      mwVe(
                        mwVsv(parameters, "parameters").cell(_mxarray53_)(
                          mwVsv(current_population, "current_population"))),
                      _mxarray165_,
                      mwVv(value, "value")));
            //
            // end
            //
            }
        //
        // 
        // end
        //
        }
    }
    //
    // 
    // if(ERROR)
    //
    if (tobool(mwVv(ERROR, "ERROR"))) {
        //
        // set(gcbo,'BackgroundColor','Red');
        //
        ans.EqAns(
          Nset(0, mwVarargin(mwVe(Ngcbo(1, NULL)), _mxarray167_, _mxarray50_)));
        //
        // set(gcbo,'ForegroundColor','White');
        //
        ans.EqAns(
          Nset(
            0, mwVarargin(mwVe(Ngcbo(1, NULL)), _mxarray169_, _mxarray171_)));
        //
        // set(status_bar_handle,'String','PLEASE CORRECT YOUR ERROR');
        //
        ans.EqAns(
          Nset(
            0,
            mwVarargin(
              mwVv(status_bar_handle, "status_bar_handle"),
              _mxarray38_,
              _mxarray173_)));
        //
        // set(status_bar_handle,'BackgroundColor','Red');
        //
        ans.EqAns(
          Nset(
            0,
            mwVarargin(
              mwVv(status_bar_handle, "status_bar_handle"),
              _mxarray167_,
              _mxarray50_)));
        //
        // set(status_bar_handle,'ForegroundColor','White');
        //
        ans.EqAns(
          Nset(
            0,
            mwVarargin(
              mwVv(status_bar_handle, "status_bar_handle"),
              _mxarray169_,
              _mxarray171_)));
    //
    // 
    // else
    //
    } else {
        //
        // set(gcbo,'BackgroundColor','White');
        //
        ans.EqAns(
          Nset(
            0, mwVarargin(mwVe(Ngcbo(1, NULL)), _mxarray167_, _mxarray171_)));
        //
        // set(gcbo,'ForegroundColor','Black');
        //
        ans.EqAns(
          Nset(
            0, mwVarargin(mwVe(Ngcbo(1, NULL)), _mxarray169_, _mxarray175_)));
        //
        // if(strcmp('PLEASE CORRECT YOUR ERROR',get(status_bar_handle,'String')))
        //
        if (tobool(
              mwVe(
                strcmp(
                  _mxarray173_,
                  mwVe(
                    Nget(
                      1,
                      mwVarargin(
                        mwVv(status_bar_handle, "status_bar_handle"),
                        _mxarray38_))))))) {
            //
            // set(status_bar_handle,'String','');
            //
            ans.EqAns(
              Nset(
                0,
                mwVarargin(
                  mwVv(status_bar_handle, "status_bar_handle"),
                  _mxarray38_,
                  _mxarray177_)));
            //
            // set(status_bar_handle,'BackgroundColor','White');
            //
            ans.EqAns(
              Nset(
                0,
                mwVarargin(
                  mwVv(status_bar_handle, "status_bar_handle"),
                  _mxarray167_,
                  _mxarray171_)));
            //
            // set(status_bar_handle,'ForegroundColor','Black');
            //
            ans.EqAns(
              Nset(
                0,
                mwVarargin(
                  mwVv(status_bar_handle, "status_bar_handle"),
                  _mxarray169_,
                  _mxarray175_)));
        //
        // end
        //
        }
    //
    // end
    //
    }
    //
    // set(multiple_population_handle,'UserData',parameters);
    //
    ans.EqAns(
      Nset(
        0,
        mwVarargin(
          mwVv(multiple_population_handle, "multiple_population_handle"),
          _mxarray36_,
          mwVv(parameters, "parameters"))));
}
