File: error.c

    1   /*
    2    * error.c
    3    *
    4    * Code generation for function 'error'
    5    *
    6    */
    7   
    8   /* Include files */
    9   #include "rt_nonfinite.h"
   10   #include "gjbf.h"
   11   #include "error.h"
   12   #include "mclms.h"
   13   #include "gjbf_mexutil.h"
   14   #include "gjbf_data.h"
   15   #include "blas.h"
   16   
   17   /* Function Definitions */
   18   void b_error(const emlrtStack *sp)
   19   {
   20     int32_T i5;
   21     const mxArray *y;
   22     char_T u[31];
   23     static const char_T varargin_1[31] = { 'f', 's', ' ', 'm', 'u', 's', 't', ' ',
   24       'b', 'e', ' ', 'p', 'o', 's', 'i', 't', 'i', 'v', 'e', ' ', 'r', 'e', 'a',
   25       'l', ' ', 's', 'c', 'a', 'l', 'a', 'r' };
   26   
   27     const mxArray *m1;
   28     static const int32_T iv3[2] = { 1, 31 };
   29   
   30     emlrtStack st;
   31     st.prev = sp;
   32     st.tls = sp->tls;
   33     for (i5 = 0; i5 < 31; i5++) {
   34       u[i5] = varargin_1[i5];
   35     }
   36   
   37     y = NULL;
   38     m1 = emlrtCreateCharArray(2, iv3);
   39     emlrtInitCharArrayR2013a(sp, 31, m1, &u[0]);
   40     emlrtAssign(&y, m1);
   41     st.site = &af_emlrtRSI;
   42     ab_error(&st, y, &emlrtMCI);
   43   }
   44   
   45   void c_error(const emlrtStack *sp)
   46   {
   47     int32_T i6;
   48     const mxArray *y;
   49     char_T u[30];
   50     static const char_T varargin_1[30] = { 's', 'p', 'o', 's', ' ', 'm', 'u', 's',
   51       't', ' ', 'b', 'e', ' ', 'a', ' ', 'r', 'e', 'a', 'l', ' ', '3', 'x', '1',
   52       ' ', 'v', 'e', 'c', 't', 'o', 'r' };
   53   
   54     const mxArray *m2;
   55     static const int32_T iv4[2] = { 1, 30 };
   56   
   57     emlrtStack st;
   58     st.prev = sp;
   59     st.tls = sp->tls;
   60     for (i6 = 0; i6 < 30; i6++) {
   61       u[i6] = varargin_1[i6];
   62     }
   63   
   64     y = NULL;
   65     m2 = emlrtCreateCharArray(2, iv4);
   66     emlrtInitCharArrayR2013a(sp, 30, m2, &u[0]);
   67     emlrtAssign(&y, m2);
   68     st.site = &af_emlrtRSI;
   69     ab_error(&st, y, &emlrtMCI);
   70   }
   71   
   72   void d_error(const emlrtStack *sp)
   73   {
   74     int32_T i8;
   75     const mxArray *y;
   76     char_T u[29];
   77     static const char_T varargin_1[29] = { 'm', 'p', 'o', 's', ' ', 'm', 'u', 's',
   78       't', ' ', 'b', 'e', ' ', 'r', 'e', 'a', 'l', ' ', 'w', 'i', 't', 'h', ' ',
   79       '3', ' ', 'r', 'o', 'w', 's' };
   80   
   81     const mxArray *m3;
   82     static const int32_T iv5[2] = { 1, 29 };
   83   
   84     emlrtStack st;
   85     st.prev = sp;
   86     st.tls = sp->tls;
   87     for (i8 = 0; i8 < 29; i8++) {
   88       u[i8] = varargin_1[i8];
   89     }
   90   
   91     y = NULL;
   92     m3 = emlrtCreateCharArray(2, iv5);
   93     emlrtInitCharArrayR2013a(sp, 29, m3, &u[0]);
   94     emlrtAssign(&y, m3);
   95     st.site = &af_emlrtRSI;
   96     ab_error(&st, y, &emlrtMCI);
   97   }
   98   
   99   void e_error(const emlrtStack *sp)
  100   {
  101     int32_T i9;
  102     const mxArray *y;
  103     char_T u[30];
  104     static const char_T varargin_1[30] = { 'c', ' ', 'm', 'u', 's', 't', ' ', 'b',
  105       'e', ' ', 'p', 'o', 's', 'i', 't', 'i', 'v', 'e', ' ', 'r', 'e', 'a', 'l',
  106       ' ', 's', 'c', 'a', 'l', 'a', 'r' };
  107   
  108     const mxArray *m4;
  109     static const int32_T iv6[2] = { 1, 30 };
  110   
  111     emlrtStack st;
  112     st.prev = sp;
  113     st.tls = sp->tls;
  114     for (i9 = 0; i9 < 30; i9++) {
  115       u[i9] = varargin_1[i9];
  116     }
  117   
  118     y = NULL;
  119     m4 = emlrtCreateCharArray(2, iv6);
  120     emlrtInitCharArrayR2013a(sp, 30, m4, &u[0]);
  121     emlrtAssign(&y, m4);
  122     st.site = &af_emlrtRSI;
  123     ab_error(&st, y, &emlrtMCI);
  124   }
  125   
  126   void error(const emlrtStack *sp)
  127   {
  128     int32_T i4;
  129     const mxArray *y;
  130     char_T u[23];
  131     static const char_T varargin_1[23] = { 'x', ' ', 'm', 'u', 's', 't', ' ', 'b',
  132       'e', ' ', 'a', ' ', 'r', 'e', 'a', 'l', ' ', 'm', 'a', 't', 'r', 'i', 'x' };
  133   
  134     const mxArray *m0;
  135     static const int32_T iv2[2] = { 1, 23 };
  136   
  137     emlrtStack st;
  138     st.prev = sp;
  139     st.tls = sp->tls;
  140     for (i4 = 0; i4 < 23; i4++) {
  141       u[i4] = varargin_1[i4];
  142     }
  143   
  144     y = NULL;
  145     m0 = emlrtCreateCharArray(2, iv2);
  146     emlrtInitCharArrayR2013a(sp, 23, m0, &u[0]);
  147     emlrtAssign(&y, m0);
  148     st.site = &af_emlrtRSI;
  149     ab_error(&st, y, &emlrtMCI);
  150   }
  151   
  152   void f_error(const emlrtStack *sp)
  153   {
  154     int32_T i10;
  155     const mxArray *y;
  156     char_T u[28];
  157     static const char_T varargin_1[28] = { 'p', ' ', 'm', 'u', 's', 't', ' ', 'b',
  158       'e', ' ', 'a', ' ', 'p', 'o', 's', 'i', 't', 'i', 'v', 'e', ' ', 'i', 'n',
  159       't', 'e', 'g', 'e', 'r' };
  160   
  161     const mxArray *m5;
  162     static const int32_T iv7[2] = { 1, 28 };
  163   
  164     emlrtStack st;
  165     st.prev = sp;
  166     st.tls = sp->tls;
  167     for (i10 = 0; i10 < 28; i10++) {
  168       u[i10] = varargin_1[i10];
  169     }
  170   
  171     y = NULL;
  172     m5 = emlrtCreateCharArray(2, iv7);
  173     emlrtInitCharArrayR2013a(sp, 28, m5, &u[0]);
  174     emlrtAssign(&y, m5);
  175     st.site = &af_emlrtRSI;
  176     ab_error(&st, y, &emlrtMCI);
  177   }
  178   
  179   void g_error(const emlrtStack *sp)
  180   {
  181     int32_T i11;
  182     const mxArray *y;
  183     char_T u[28];
  184     static const char_T varargin_1[28] = { 'q', ' ', 'm', 'u', 's', 't', ' ', 'b',
  185       'e', ' ', 'a', ' ', 'p', 'o', 's', 'i', 't', 'i', 'v', 'e', ' ', 'i', 'n',
  186       't', 'e', 'g', 'e', 'r' };
  187   
  188     const mxArray *m6;
  189     static const int32_T iv8[2] = { 1, 28 };
  190   
  191     emlrtStack st;
  192     st.prev = sp;
  193     st.tls = sp->tls;
  194     for (i11 = 0; i11 < 28; i11++) {
  195       u[i11] = varargin_1[i11];
  196     }
  197   
  198     y = NULL;
  199     m6 = emlrtCreateCharArray(2, iv8);
  200     emlrtInitCharArrayR2013a(sp, 28, m6, &u[0]);
  201     emlrtAssign(&y, m6);
  202     st.site = &af_emlrtRSI;
  203     ab_error(&st, y, &emlrtMCI);
  204   }
  205   
  206   void h_error(const emlrtStack *sp)
  207   {
  208     int32_T i12;
  209     const mxArray *y;
  210     char_T u[24];
  211     static const char_T varargin_1[24] = { 'm', 'u', ' ', 'm', 'u', 's', 't', ' ',
  212       'b', 'e', ' ', 'a', ' ', 'r', 'e', 'a', 'l', ' ', 's', 'c', 'a', 'l', 'a',
  213       'r' };
  214   
  215     const mxArray *m7;
  216     static const int32_T iv9[2] = { 1, 24 };
  217   
  218     emlrtStack st;
  219     st.prev = sp;
  220     st.tls = sp->tls;
  221     for (i12 = 0; i12 < 24; i12++) {
  222       u[i12] = varargin_1[i12];
  223     }
  224   
  225     y = NULL;
  226     m7 = emlrtCreateCharArray(2, iv9);
  227     emlrtInitCharArrayR2013a(sp, 24, m7, &u[0]);
  228     emlrtAssign(&y, m7);
  229     st.site = &af_emlrtRSI;
  230     ab_error(&st, y, &emlrtMCI);
  231   }
  232   
  233   void i_error(const emlrtStack *sp)
  234   {
  235     int32_T i13;
  236     const mxArray *y;
  237     char_T u[32];
  238     static const char_T varargin_1[32] = { 'o', 'r', 'd', 'e', 'r', ' ', 'm', 'u',
  239       's', 't', ' ', 'b', 'e', ' ', 'a', ' ', 'p', 'o', 's', 'i', 't', 'i', 'v',
  240       'e', ' ', 'i', 'n', 't', 'e', 'g', 'e', 'r' };
  241   
  242     const mxArray *m8;
  243     static const int32_T iv10[2] = { 1, 32 };
  244   
  245     emlrtStack st;
  246     st.prev = sp;
  247     st.tls = sp->tls;
  248     for (i13 = 0; i13 < 32; i13++) {
  249       u[i13] = varargin_1[i13];
  250     }
  251   
  252     y = NULL;
  253     m8 = emlrtCreateCharArray(2, iv10);
  254     emlrtInitCharArrayR2013a(sp, 32, m8, &u[0]);
  255     emlrtAssign(&y, m8);
  256     st.site = &af_emlrtRSI;
  257     ab_error(&st, y, &emlrtMCI);
  258   }
  259   
  260   void j_error(const emlrtStack *sp)
  261   {
  262     int32_T i14;
  263     const mxArray *y;
  264     char_T u[35];
  265     static const char_T varargin_1[35] = { 'b', 'e', 't', 'a', ' ', 'm', 'u', 's',
  266       't', ' ', 'b', 'e', ' ', 'a', ' ', 'r', 'e', 'a', 'l', ' ', 's', 'c', 'a',
  267       'l', 'a', 'r', ' ', 'i', 'n', ' ', '[', '0', ',', '1', ']' };
  268   
  269     const mxArray *m9;
  270     static const int32_T iv11[2] = { 1, 35 };
  271   
  272     emlrtStack st;
  273     st.prev = sp;
  274     st.tls = sp->tls;
  275     for (i14 = 0; i14 < 35; i14++) {
  276       u[i14] = varargin_1[i14];
  277     }
  278   
  279     y = NULL;
  280     m9 = emlrtCreateCharArray(2, iv11);
  281     emlrtInitCharArrayR2013a(sp, 35, m9, &u[0]);
  282     emlrtAssign(&y, m9);
  283     st.site = &af_emlrtRSI;
  284     ab_error(&st, y, &emlrtMCI);
  285   }
  286   
  287   void k_error(const emlrtStack *sp)
  288   {
  289     int32_T i16;
  290     const mxArray *y;
  291     char_T u[25];
  292     static const char_T varargin_1[25] = { 'p', 'h', 'i', ' ', 'm', 'u', 's', 't',
  293       ' ', 'b', 'e', ' ', 'a', ' ', 'r', 'e', 'a', 'l', ' ', 'm', 'a', 't', 'r',
  294       'i', 'x' };
  295   
  296     const mxArray *m10;
  297     static const int32_T iv12[2] = { 1, 25 };
  298   
  299     emlrtStack st;
  300     st.prev = sp;
  301     st.tls = sp->tls;
  302     for (i16 = 0; i16 < 25; i16++) {
  303       u[i16] = varargin_1[i16];
  304     }
  305   
  306     y = NULL;
  307     m10 = emlrtCreateCharArray(2, iv12);
  308     emlrtInitCharArrayR2013a(sp, 25, m10, &u[0]);
  309     emlrtAssign(&y, m10);
  310     st.site = &af_emlrtRSI;
  311     ab_error(&st, y, &emlrtMCI);
  312   }
  313   
  314   void l_error(const emlrtStack *sp)
  315   {
  316     int32_T i17;
  317     const mxArray *y;
  318     char_T u[25];
  319     static const char_T varargin_1[25] = { 'p', 's', 'i', ' ', 'm', 'u', 's', 't',
  320       ' ', 'b', 'e', ' ', 'a', ' ', 'r', 'e', 'a', 'l', ' ', 'm', 'a', 't', 'r',
  321       'i', 'x' };
  322   
  323     const mxArray *m11;
  324     static const int32_T iv13[2] = { 1, 25 };
  325   
  326     emlrtStack st;
  327     st.prev = sp;
  328     st.tls = sp->tls;
  329     for (i17 = 0; i17 < 25; i17++) {
  330       u[i17] = varargin_1[i17];
  331     }
  332   
  333     y = NULL;
  334     m11 = emlrtCreateCharArray(2, iv13);
  335     emlrtInitCharArrayR2013a(sp, 25, m11, &u[0]);
  336     emlrtAssign(&y, m11);
  337     st.site = &af_emlrtRSI;
  338     ab_error(&st, y, &emlrtMCI);
  339   }
  340   
  341   void m_error(const emlrtStack *sp)
  342   {
  343     int32_T i18;
  344     const mxArray *y;
  345     char_T u[32];
  346     static const char_T varargin_1[32] = { 'K', ' ', 'm', 'u', 's', 't', ' ', 'b',
  347       'e', ' ', 'a', ' ', 'r', 'e', 'a', 'l', ' ', 'p', 'o', 's', 'i', 't', 'i',
  348       'v', 'e', ' ', 's', 'c', 'a', 'l', 'a', 'r' };
  349   
  350     const mxArray *m12;
  351     static const int32_T iv14[2] = { 1, 32 };
  352   
  353     emlrtStack st;
  354     st.prev = sp;
  355     st.tls = sp->tls;
  356     for (i18 = 0; i18 < 32; i18++) {
  357       u[i18] = varargin_1[i18];
  358     }
  359   
  360     y = NULL;
  361     m12 = emlrtCreateCharArray(2, iv14);
  362     emlrtInitCharArrayR2013a(sp, 32, m12, &u[0]);
  363     emlrtAssign(&y, m12);
  364     st.site = &af_emlrtRSI;
  365     ab_error(&st, y, &emlrtMCI);
  366   }
  367   
  368   void n_error(const emlrtStack *sp)
  369   {
  370     int32_T i20;
  371     const mxArray *y;
  372     char_T u[27];
  373     static const char_T varargin_1[27] = { 'x', 'P', 'r', 'e', 'v', ' ', 'm', 'u',
  374       's', 't', ' ', 'b', 'e', ' ', 'a', ' ', 'r', 'e', 'a', 'l', ' ', 'm', 'a',
  375       't', 'r', 'i', 'x' };
  376   
  377     const mxArray *m13;
  378     static const int32_T iv15[2] = { 1, 27 };
  379   
  380     emlrtStack st;
  381     st.prev = sp;
  382     st.tls = sp->tls;
  383     for (i20 = 0; i20 < 27; i20++) {
  384       u[i20] = varargin_1[i20];
  385     }
  386   
  387     y = NULL;
  388     m13 = emlrtCreateCharArray(2, iv15);
  389     emlrtInitCharArrayR2013a(sp, 27, m13, &u[0]);
  390     emlrtAssign(&y, m13);
  391     st.site = &af_emlrtRSI;
  392     ab_error(&st, y, &emlrtMCI);
  393   }
  394   
  395   void o_error(const emlrtStack *sp)
  396   {
  397     int32_T i22;
  398     const mxArray *y;
  399     char_T u[24];
  400     static const char_T varargin_1[24] = { 'b', 'p', ' ', 'm', 'u', 's', 't', ' ',
  401       'b', 'e', ' ', 'a', ' ', 'r', 'e', 'a', 'l', ' ', 'v', 'e', 'c', 't', 'o',
  402       'r' };
  403   
  404     const mxArray *m14;
  405     static const int32_T iv16[2] = { 1, 24 };
  406   
  407     emlrtStack st;
  408     st.prev = sp;
  409     st.tls = sp->tls;
  410     for (i22 = 0; i22 < 24; i22++) {
  411       u[i22] = varargin_1[i22];
  412     }
  413   
  414     y = NULL;
  415     m14 = emlrtCreateCharArray(2, iv16);
  416     emlrtInitCharArrayR2013a(sp, 24, m14, &u[0]);
  417     emlrtAssign(&y, m14);
  418     st.site = &af_emlrtRSI;
  419     ab_error(&st, y, &emlrtMCI);
  420   }
  421   
  422   void p_error(const emlrtStack *sp)
  423   {
  424     int32_T i23;
  425     const mxArray *y;
  426     char_T u[24];
  427     static const char_T varargin_1[24] = { 'z', 'p', ' ', 'm', 'u', 's', 't', ' ',
  428       'b', 'e', ' ', 'a', ' ', 'r', 'e', 'a', 'l', ' ', 'm', 'a', 't', 'r', 'i',
  429       'x' };
  430   
  431     const mxArray *m15;
  432     static const int32_T iv17[2] = { 1, 24 };
  433   
  434     emlrtStack st;
  435     st.prev = sp;
  436     st.tls = sp->tls;
  437     for (i23 = 0; i23 < 24; i23++) {
  438       u[i23] = varargin_1[i23];
  439     }
  440   
  441     y = NULL;
  442     m15 = emlrtCreateCharArray(2, iv17);
  443     emlrtInitCharArrayR2013a(sp, 24, m15, &u[0]);
  444     emlrtAssign(&y, m15);
  445     st.site = &af_emlrtRSI;
  446     ab_error(&st, y, &emlrtMCI);
  447   }
  448   
  449   void q_error(const emlrtStack *sp)
  450   {
  451     int32_T i24;
  452     const mxArray *y;
  453     char_T u[25];
  454     static const char_T varargin_1[25] = { 'b', 'w', '1', ' ', 'm', 'u', 's', 't',
  455       ' ', 'b', 'e', ' ', 'a', ' ', 'r', 'e', 'a', 'l', ' ', 'm', 'a', 't', 'r',
  456       'i', 'x' };
  457   
  458     const mxArray *m16;
  459     static const int32_T iv18[2] = { 1, 25 };
  460   
  461     emlrtStack st;
  462     st.prev = sp;
  463     st.tls = sp->tls;
  464     for (i24 = 0; i24 < 25; i24++) {
  465       u[i24] = varargin_1[i24];
  466     }
  467   
  468     y = NULL;
  469     m16 = emlrtCreateCharArray(2, iv18);
  470     emlrtInitCharArrayR2013a(sp, 25, m16, &u[0]);
  471     emlrtAssign(&y, m16);
  472     st.site = &af_emlrtRSI;
  473     ab_error(&st, y, &emlrtMCI);
  474   }
  475   
  476   void r_error(const emlrtStack *sp)
  477   {
  478     int32_T i25;
  479     const mxArray *y;
  480     char_T u[25];
  481     static const char_T varargin_1[25] = { 'm', 'w', '1', ' ', 'm', 'u', 's', 't',
  482       ' ', 'b', 'e', ' ', 'a', ' ', 'r', 'e', 'a', 'l', ' ', 'm', 'a', 't', 'r',
  483       'i', 'x' };
  484   
  485     const mxArray *m17;
  486     static const int32_T iv19[2] = { 1, 25 };
  487   
  488     emlrtStack st;
  489     st.prev = sp;
  490     st.tls = sp->tls;
  491     for (i25 = 0; i25 < 25; i25++) {
  492       u[i25] = varargin_1[i25];
  493     }
  494   
  495     y = NULL;
  496     m17 = emlrtCreateCharArray(2, iv19);
  497     emlrtInitCharArrayR2013a(sp, 25, m17, &u[0]);
  498     emlrtAssign(&y, m17);
  499     st.site = &af_emlrtRSI;
  500     ab_error(&st, y, &emlrtMCI);
  501   }
  502   
  503   void s_error(const emlrtStack *sp)
  504   {
  505     int32_T i26;
  506     const mxArray *y;
  507     char_T u[40];
  508     static const char_T varargin_1[40] = { 's', 'n', 'r', 'T', 'h', 'r', 'e', 's',
  509       'h', ' ', 'm', 'u', 's', 't', ' ', 'b', 'e', ' ', 'a', ' ', 'p', 'o', 's',
  510       'i', 't', 'i', 'v', 'e', ' ', 'r', 'e', 'a', 'l', ' ', 's', 'c', 'a', 'l',
  511       'a', 'r' };
  512   
  513     const mxArray *m18;
  514     static const int32_T iv20[2] = { 1, 40 };
  515   
  516     emlrtStack st;
  517     st.prev = sp;
  518     st.tls = sp->tls;
  519     for (i26 = 0; i26 < 40; i26++) {
  520       u[i26] = varargin_1[i26];
  521     }
  522   
  523     y = NULL;
  524     m18 = emlrtCreateCharArray(2, iv20);
  525     emlrtInitCharArrayR2013a(sp, 40, m18, &u[0]);
  526     emlrtAssign(&y, m18);
  527     st.site = &af_emlrtRSI;
  528     ab_error(&st, y, &emlrtMCI);
  529   }
  530   
  531   void t_error(const emlrtStack *sp)
  532   {
  533     int32_T i27;
  534     const mxArray *y;
  535     char_T u[34];
  536     static const char_T varargin_1[34] = { 's', 'n', 'r', 'R', 'a', 't', 'e', ' ',
  537       'm', 'u', 's', 't', ' ', 'b', 'e', ' ', 'a', ' ', 'p', 'o', 's', 'i', 't',
  538       'i', 'v', 'e', ' ', 'i', 'n', 't', 'e', 'g', 'e', 'r' };
  539   
  540     const mxArray *m19;
  541     static const int32_T iv21[2] = { 1, 34 };
  542   
  543     emlrtStack st;
  544     st.prev = sp;
  545     st.tls = sp->tls;
  546     for (i27 = 0; i27 < 34; i27++) {
  547       u[i27] = varargin_1[i27];
  548     }
  549   
  550     y = NULL;
  551     m19 = emlrtCreateCharArray(2, iv21);
  552     emlrtInitCharArrayR2013a(sp, 34, m19, &u[0]);
  553     emlrtAssign(&y, m19);
  554     st.site = &af_emlrtRSI;
  555     ab_error(&st, y, &emlrtMCI);
  556   }
  557   
  558   void u_error(const emlrtStack *sp)
  559   {
  560     int32_T i29;
  561     const mxArray *y;
  562     char_T u[38];
  563     static const char_T varargin_1[38] = { 'm', 'p', 'o', 's', ' ', 'm', 'u', 's',
  564       't', ' ', 'b', 'e', ' ', 'a', ' ', 'r', 'e', 'a', 'l', ' ', 'm', 'a', 't',
  565       'r', 'i', 'x', ' ', 'w', 'i', 't', 'h', ' ', '3', ' ', 'r', 'o', 'w', 's' };
  566   
  567     const mxArray *m20;
  568     static const int32_T iv23[2] = { 1, 38 };
  569   
  570     emlrtStack st;
  571     st.prev = sp;
  572     st.tls = sp->tls;
  573     for (i29 = 0; i29 < 38; i29++) {
  574       u[i29] = varargin_1[i29];
  575     }
  576   
  577     y = NULL;
  578     m20 = emlrtCreateCharArray(2, iv23);
  579     emlrtInitCharArrayR2013a(sp, 38, m20, &u[0]);
  580     emlrtAssign(&y, m20);
  581     st.site = &af_emlrtRSI;
  582     ab_error(&st, y, &emlrtMCI);
  583   }
  584   
  585   void x_error(const emlrtStack *sp)
  586   {
  587     int32_T i30;
  588     const mxArray *y;
  589     char_T u[34];
  590     static const char_T varargin_1[34] = { 'C', 'a', 'n', 't', ' ', 'h', 'a', 'v',
  591       'e', ' ', 'a', ' ', 's', 'o', 'u', 'r', 'c', 'e', ' ', 'o', 'n', ' ', 't',
  592       'o', 'p', ' ', 'o', 'f', ' ', 'a', ' ', 'm', 'i', 'c' };
  593   
  594     const mxArray *m21;
  595     static const int32_T iv24[2] = { 1, 34 };
  596   
  597     emlrtStack st;
  598     st.prev = sp;
  599     st.tls = sp->tls;
  600     for (i30 = 0; i30 < 34; i30++) {
  601       u[i30] = varargin_1[i30];
  602     }
  603   
  604     y = NULL;
  605     m21 = emlrtCreateCharArray(2, iv24);
  606     emlrtInitCharArrayR2013a(sp, 34, m21, &u[0]);
  607     emlrtAssign(&y, m21);
  608     st.site = &af_emlrtRSI;
  609     ab_error(&st, y, &emlrtMCI);
  610   }
  611   
  612   /* End of code generation (error.c) */
  613