mono_class_get_methods_by_name (struct MonoClass * klass, const char * name, guint32 bflags, gboolean ignore_case, gboolean allow_ctors, struct MonoException * * ex)
{
  int (*<T3a56>) (const char *, const char *) iftmp.0;
  long unsigned int D.26129;
  long unsigned int D.26130;
  int D.22763;
  int iftmp.1;
  int D.22762;
  const char[7] * D.26138;
  unsigned char D.26139;
  int D.26140;
  unsigned char D.26141;
  int D.26142;
  const unsigned char * D.26147;
  unsigned char D.26148;
  int D.26149;
  const unsigned char * D.26150;
  unsigned char D.26151;
  int D.26152;
  const unsigned char * D.26157;
  unsigned char D.26158;
  int D.26159;
  const unsigned char * D.26160;
  unsigned char D.26161;
  int D.26162;
  const unsigned char * D.26167;
  unsigned char D.26168;
  int D.26169;
  const unsigned char * D.26170;
  unsigned char D.26171;
  int D.26172;
  struct MonoLoaderError * D.26178;
  struct GPtrArray * D.26180;
  unsigned char D.26181;
  struct MonoLoaderError * D.26183;
  struct MonoType * D.26185;
  unsigned char D.26186;
  struct MonoClass * D.26189;
  int iftmp.2;
  unsigned int D.26195;
  unsigned int D.26196;
  unsigned char D.26198;
  unsigned int nslots.3;
  int D.26203;
  int D.26204;
  long unsigned int D.26205;
  long unsigned int D.26206;
  struct MonoLoaderError * D.26209;
  short int D.26211;
  int D.26214;
  _Bool D.26215;
  long int D.26216;
  long int D.26217;
  short int D.26220;
  long unsigned int D.26221;
  long unsigned int D.26222;
  guint32 * D.26223;
  unsigned int D.26224;
  unsigned short D.26225;
  int D.26226;
  int D.26227;
  int D.26228;
  unsigned int D.26229;
  unsigned int D.26230;
  short unsigned int D.26233;
  int D.26234;
  int D.26235;
  unsigned int D.26238;
  const char * D.26243;
  char D.26244;
  int D.22775;
  int iftmp.4;
  int D.22774;
  const char[6] * D.26250;
  unsigned char D.26251;
  int D.26252;
  unsigned char D.26253;
  int D.26254;
  const unsigned char * D.26259;
  unsigned char D.26260;
  int D.26261;
  const unsigned char * D.26262;
  unsigned char D.26263;
  int D.26264;
  const unsigned char * D.26269;
  unsigned char D.26270;
  int D.26271;
  const unsigned char * D.26272;
  unsigned char D.26273;
  int D.26274;
  const unsigned char * D.26279;
  unsigned char D.26280;
  int D.26281;
  const unsigned char * D.26282;
  unsigned char D.26283;
  int D.26284;
  int D.22784;
  int iftmp.5;
  int D.22783;
  const char[7] * D.26290;
  unsigned char D.26291;
  int D.26292;
  unsigned char D.26293;
  int D.26294;
  const unsigned char * D.26299;
  unsigned char D.26300;
  int D.26301;
  const unsigned char * D.26302;
  unsigned char D.26303;
  int D.26304;
  const unsigned char * D.26309;
  unsigned char D.26310;
  int D.26311;
  const unsigned char * D.26312;
  unsigned char D.26313;
  int D.26314;
  const unsigned char * D.26319;
  unsigned char D.26320;
  int D.26321;
  const unsigned char * D.26322;
  unsigned char D.26323;
  int D.26324;
  int D.26326;
  unsigned int D.26329;
  unsigned int D.26333;
  _Bool D.26336;
  int D.26337;
  int D.26338;
  int D.26343;
  unsigned int D.26346;
  unsigned int D.26351;
  unsigned int D.26354;
  int D.26361;
  unsigned int D.26364;
  struct MonoException * D.26374;
  struct MonoLoaderError * D.26376;
  struct MonoException * D.26377;
  struct GPtrArray * array;
  struct MonoClass * startklass;
  struct MonoMethod * method;
  void * iter;
  int len;
  int match;
  int nslots;
  guint32 method_slots_default[8];
  guint32 * method_slots;
  int (*<T3a56>) (const char *, const char *) compare_func;
  void loader_error = <<< error >>>;
  void handle_parent = <<< error >>>;

  try
    {
      method_slots = 0B;
      compare_func = 0B;
      array = monoeg_g_ptr_array_new ();
      startklass = klass;
      *ex = 0B;
      len = 0;
      if (name != 0B) goto <D.26123>; else goto <D.26124>;
      <D.26123>:
      if (ignore_case != 0) goto <D.26126>; else goto <D.26127>;
      <D.26126>:
      iftmp.0 = monoeg_ascii_strcasecmp;
      goto <D.26128>;
      <D.26127>:
      iftmp.0 = strcmp;
      <D.26128>:
      compare_func = iftmp.0;
      <D.26124>:
      D.26129 = BIT_FIELD_REF <*klass, 64, 256>;
      D.26130 = D.26129 & 16777216;
      if (D.26130 != 0) goto <D.26131>; else goto <D.26132>;
      <D.26131>:
      if (name != 0B) goto <D.26133>; else goto <D.26134>;
      <D.26133>:
      {
        size_t __s1_len;
        size_t __s2_len;

        __s2_len = 6;
        if (__s2_len <= 3) goto <D.26136>; else goto <D.26137>;
        <D.26136>:
        {
          const unsigned char * __s2;
          int __result;

          __s2 = name;
          D.26138 = "Invoke";
          D.26139 = MEM[(const unsigned char *)D.26138];
          D.26140 = (int) D.26139;
          D.26141 = *__s2;
          D.26142 = (int) D.26141;
          __result = D.26140 - D.26142;
          {
            if (__s2_len != 0) goto <D.26143>; else goto <D.26144>;
            <D.26143>:
            if (__result == 0) goto <D.26145>; else goto <D.26146>;
            <D.26145>:
            D.26147 = &MEM[(void *)"Invoke" + 1B];
            D.26148 = *D.26147;
            D.26149 = (int) D.26148;
            D.26150 = __s2 + 1;
            D.26151 = *D.26150;
            D.26152 = (int) D.26151;
            __result = D.26149 - D.26152;
            if (__s2_len > 1) goto <D.26153>; else goto <D.26154>;
            <D.26153>:
            if (__result == 0) goto <D.26155>; else goto <D.26156>;
            <D.26155>:
            D.26157 = &MEM[(void *)"Invoke" + 2B];
            D.26158 = *D.26157;
            D.26159 = (int) D.26158;
            D.26160 = __s2 + 2;
            D.26161 = *D.26160;
            D.26162 = (int) D.26161;
            __result = D.26159 - D.26162;
            if (__s2_len > 2) goto <D.26163>; else goto <D.26164>;
            <D.26163>:
            if (__result == 0) goto <D.26165>; else goto <D.26166>;
            <D.26165>:
            D.26167 = &MEM[(void *)"Invoke" + 3B];
            D.26168 = *D.26167;
            D.26169 = (int) D.26168;
            D.26170 = __s2 + 3;
            D.26171 = *D.26170;
            D.26172 = (int) D.26171;
            __result = D.26169 - D.26172;
            <D.26166>:
            <D.26164>:
            <D.26156>:
            <D.26154>:
            <D.26146>:
            <D.26144>:
          }
          D.22762 = __result;
        }
        iftmp.1 = -D.22762;
        goto <D.26173>;
        <D.26137>:
        iftmp.1 = __builtin_strcmp (name, "Invoke");
        <D.26173>:
        D.22763 = iftmp.1;
      }
      if (D.22763 == 0) goto <D.26174>; else goto <D.26175>;
      <D.26174>:
      if (bflags == 28) goto <D.26176>; else goto <D.26177>;
      <D.26176>:
      method = mono_get_delegate_invoke (klass);
      D.26178 = mono_loader_get_last_error ();
      if (D.26178 != 0B) goto loader_error; else goto <D.26179>;
      <D.26179>:
      monoeg_g_ptr_array_add (array, method);
      D.26180 = array;
      return D.26180;
      <D.26177>:
      <D.26175>:
      <D.26134>:
      <D.26132>:
      mono_class_setup_vtable (klass);
      D.26181 = klass->exception_type;
      if (D.26181 != 0) goto loader_error; else goto <D.26182>;
      <D.26182>:
      D.26183 = mono_loader_get_last_error ();
      if (D.26183 != 0B) goto loader_error; else goto <D.26184>;
      <D.26184>:
      D.26185 = &klass->byval_arg;
      D.26186 = is_generic_parameter (D.26185);
      if (D.26186 != 0) goto <D.26187>; else goto <D.26188>;
      <D.26187>:
      D.26189 = klass->parent;
      nslots = mono_class_get_vtable_size (D.26189);
      goto <D.26190>;
      <D.26188>:
      D.26195 = klass->flags;
      D.26196 = D.26195 & 32;
      if (D.26196 != 0) goto <D.26192>; else goto <D.26197>;
      <D.26197>:
      D.26198 = klass->byval_arg.type;
      if (D.26198 == 19) goto <D.26192>; else goto <D.26199>;
      <D.26199>:
      D.26198 = klass->byval_arg.type;
      if (D.26198 == 30) goto <D.26192>; else goto <D.26193>;
      <D.26192>:
      iftmp.2 = mono_class_num_methods (klass);
      goto <D.26194>;
      <D.26193>:
      iftmp.2 = mono_class_get_vtable_size (klass);
      <D.26194>:
      nslots = iftmp.2;
      <D.26190>:
      nslots.3 = (unsigned int) nslots;
      if (nslots.3 > 255) goto <D.26201>; else goto <D.26202>;
      <D.26201>:
      D.26203 = nslots / 32;
      D.26204 = D.26203 + 1;
      D.26205 = (long unsigned int) D.26204;
      D.26206 = D.26205 * 4;
      method_slots = monoeg_malloc0 (D.26206);
      goto <D.26207>;
      <D.26202>:
      method_slots = &method_slots_default;
      memset (method_slots, 0, 32);
      <D.26207>:
      handle_parent:
      mono_class_setup_vtable (klass);
      D.26181 = klass->exception_type;
      if (D.26181 != 0) goto loader_error; else goto <D.26208>;
      <D.26208>:
      D.26209 = mono_loader_get_last_error ();
      if (D.26209 != 0B) goto loader_error; else goto <D.26210>;
      <D.26210>:
      iter = 0B;
      goto <D.22766>;
      <D.22785>:
      match = 0;
      D.26211 = method->slot;
      if (D.26211 != -1) goto <D.26212>; else goto <D.26213>;
      <D.26212>:
      D.26211 = method->slot;
      D.26214 = (int) D.26211;
      D.26215 = D.26214 >= nslots;
      D.26216 = (long int) D.26215;
      D.26217 = __builtin_expect (D.26216, 0);
      if (D.26217 != 0) goto <D.26218>; else goto <D.26219>;
      <D.26218>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "icall.c", 3493, "method->slot < nslots");
      <D.26219>:
      D.26211 = method->slot;
      D.26220 = D.26211 >> 5;
      D.26221 = (long unsigned int) D.26220;
      D.26222 = D.26221 * 4;
      D.26223 = method_slots + D.26222;
      D.26224 = *D.26223;
      D.26211 = method->slot;
      D.26225 = (unsigned short) D.26211;
      D.26226 = (int) D.26225;
      D.26227 = D.26226 & 31;
      D.26228 = 1 << D.26227;
      D.26229 = (unsigned int) D.26228;
      D.26230 = D.26224 & D.26229;
      if (D.26230 != 0) goto <D.26231>; else goto <D.26232>;
      <D.26231>:
      // predicted unlikely by continue predictor.
      goto <D.22766>;
      <D.26232>:
      D.26233 = method->flags;
      D.26234 = (int) D.26233;
      D.26235 = D.26234 & 256;
      if (D.26235 == 0) goto <D.26236>; else goto <D.26237>;
      <D.26236>:
      D.26211 = method->slot;
      D.26220 = D.26211 >> 5;
      D.26221 = (long unsigned int) D.26220;
      D.26222 = D.26221 * 4;
      D.26223 = method_slots + D.26222;
      D.26211 = method->slot;
      D.26220 = D.26211 >> 5;
      D.26221 = (long unsigned int) D.26220;
      D.26222 = D.26221 * 4;
      D.26223 = method_slots + D.26222;
      D.26224 = *D.26223;
      D.26211 = method->slot;
      D.26225 = (unsigned short) D.26211;
      D.26226 = (int) D.26225;
      D.26227 = D.26226 & 31;
      D.26228 = 1 << D.26227;
      D.26229 = (unsigned int) D.26228;
      D.26238 = D.26224 | D.26229;
      *D.26223 = D.26238;
      <D.26237>:
      <D.26213>:
      if (allow_ctors == 0) goto <D.26241>; else goto <D.26242>;
      <D.26241>:
      D.26243 = method->name;
      D.26244 = *D.26243;
      if (D.26244 == 46) goto <D.26245>; else goto <D.26246>;
      <D.26245>:
      {
        size_t __s1_len;
        size_t __s2_len;

        __s2_len = 5;
        if (__s2_len <= 3) goto <D.26248>; else goto <D.26249>;
        <D.26248>:
        {
          const unsigned char * __s2;
          int __result;

          __s2 = method->name;
          D.26250 = ".ctor";
          D.26251 = MEM[(const unsigned char *)D.26250];
          D.26252 = (int) D.26251;
          D.26253 = *__s2;
          D.26254 = (int) D.26253;
          __result = D.26252 - D.26254;
          {
            if (__s2_len != 0) goto <D.26255>; else goto <D.26256>;
            <D.26255>:
            if (__result == 0) goto <D.26257>; else goto <D.26258>;
            <D.26257>:
            D.26259 = &MEM[(void *)".ctor" + 1B];
            D.26260 = *D.26259;
            D.26261 = (int) D.26260;
            D.26262 = __s2 + 1;
            D.26263 = *D.26262;
            D.26264 = (int) D.26263;
            __result = D.26261 - D.26264;
            if (__s2_len > 1) goto <D.26265>; else goto <D.26266>;
            <D.26265>:
            if (__result == 0) goto <D.26267>; else goto <D.26268>;
            <D.26267>:
            D.26269 = &MEM[(void *)".ctor" + 2B];
            D.26270 = *D.26269;
            D.26271 = (int) D.26270;
            D.26272 = __s2 + 2;
            D.26273 = *D.26272;
            D.26274 = (int) D.26273;
            __result = D.26271 - D.26274;
            if (__s2_len > 2) goto <D.26275>; else goto <D.26276>;
            <D.26275>:
            if (__result == 0) goto <D.26277>; else goto <D.26278>;
            <D.26277>:
            D.26279 = &MEM[(void *)".ctor" + 3B];
            D.26280 = *D.26279;
            D.26281 = (int) D.26280;
            D.26282 = __s2 + 3;
            D.26283 = *D.26282;
            D.26284 = (int) D.26283;
            __result = D.26281 - D.26284;
            <D.26278>:
            <D.26276>:
            <D.26268>:
            <D.26266>:
            <D.26258>:
            <D.26256>:
          }
          D.22774 = __result;
        }
        iftmp.4 = -D.22774;
        goto <D.26285>;
        <D.26249>:
        D.26243 = method->name;
        iftmp.4 = __builtin_strcmp (D.26243, ".ctor");
        <D.26285>:
        D.22775 = iftmp.4;
      }
      if (D.22775 == 0) goto <D.26239>; else goto <D.26286>;
      <D.26286>:
      {
        size_t __s1_len;
        size_t __s2_len;

        __s2_len = 6;
        if (__s2_len <= 3) goto <D.26288>; else goto <D.26289>;
        <D.26288>:
        {
          const unsigned char * __s2;
          int __result;

          __s2 = method->name;
          D.26290 = ".cctor";
          D.26291 = MEM[(const unsigned char *)D.26290];
          D.26292 = (int) D.26291;
          D.26293 = *__s2;
          D.26294 = (int) D.26293;
          __result = D.26292 - D.26294;
          {
            if (__s2_len != 0) goto <D.26295>; else goto <D.26296>;
            <D.26295>:
            if (__result == 0) goto <D.26297>; else goto <D.26298>;
            <D.26297>:
            D.26299 = &MEM[(void *)".cctor" + 1B];
            D.26300 = *D.26299;
            D.26301 = (int) D.26300;
            D.26302 = __s2 + 1;
            D.26303 = *D.26302;
            D.26304 = (int) D.26303;
            __result = D.26301 - D.26304;
            if (__s2_len > 1) goto <D.26305>; else goto <D.26306>;
            <D.26305>:
            if (__result == 0) goto <D.26307>; else goto <D.26308>;
            <D.26307>:
            D.26309 = &MEM[(void *)".cctor" + 2B];
            D.26310 = *D.26309;
            D.26311 = (int) D.26310;
            D.26312 = __s2 + 2;
            D.26313 = *D.26312;
            D.26314 = (int) D.26313;
            __result = D.26311 - D.26314;
            if (__s2_len > 2) goto <D.26315>; else goto <D.26316>;
            <D.26315>:
            if (__result == 0) goto <D.26317>; else goto <D.26318>;
            <D.26317>:
            D.26319 = &MEM[(void *)".cctor" + 3B];
            D.26320 = *D.26319;
            D.26321 = (int) D.26320;
            D.26322 = __s2 + 3;
            D.26323 = *D.26322;
            D.26324 = (int) D.26323;
            __result = D.26321 - D.26324;
            <D.26318>:
            <D.26316>:
            <D.26308>:
            <D.26306>:
            <D.26298>:
            <D.26296>:
          }
          D.22783 = __result;
        }
        iftmp.5 = -D.22783;
        goto <D.26325>;
        <D.26289>:
        D.26243 = method->name;
        iftmp.5 = __builtin_strcmp (D.26243, ".cctor");
        <D.26325>:
        D.22784 = iftmp.5;
      }
      if (D.22784 == 0) goto <D.26239>; else goto <D.26240>;
      <D.26239>:
      // predicted unlikely by continue predictor.
      goto <D.22766>;
      <D.26240>:
      <D.26246>:
      <D.26242>:
      D.26233 = method->flags;
      D.26234 = (int) D.26233;
      D.26326 = D.26234 & 7;
      if (D.26326 == 6) goto <D.26327>; else goto <D.26328>;
      <D.26327>:
      D.26329 = bflags & 16;
      if (D.26329 != 0) goto <D.26330>; else goto <D.26331>;
      <D.26330>:
      match = match + 1;
      <D.26331>:
      goto <D.26332>;
      <D.26328>:
      D.26333 = bflags & 32;
      if (D.26333 != 0) goto <D.26334>; else goto <D.26335>;
      <D.26334>:
      D.26336 = klass == startklass;
      D.26337 = (int) D.26336;
      D.26338 = method_nonpublic (method, D.26337);
      if (D.26338 != 0) goto <D.26339>; else goto <D.26340>;
      <D.26339>:
      match = match + 1;
      <D.26340>:
      <D.26335>:
      <D.26332>:
      if (match == 0) goto <D.26341>; else goto <D.26342>;
      <D.26341>:
      // predicted unlikely by continue predictor.
      goto <D.22766>;
      <D.26342>:
      match = 0;
      D.26233 = method->flags;
      D.26234 = (int) D.26233;
      D.26343 = D.26234 & 16;
      if (D.26343 != 0) goto <D.26344>; else goto <D.26345>;
      <D.26344>:
      D.26346 = bflags & 8;
      if (D.26346 != 0) goto <D.26347>; else goto <D.26348>;
      <D.26347>:
      D.26351 = bflags & 64;
      if (D.26351 != 0) goto <D.26349>; else goto <D.26352>;
      <D.26352>:
      if (klass == startklass) goto <D.26349>; else goto <D.26350>;
      <D.26349>:
      match = match + 1;
      <D.26350>:
      <D.26348>:
      goto <D.26353>;
      <D.26345>:
      D.26354 = bflags & 4;
      if (D.26354 != 0) goto <D.26355>; else goto <D.26356>;
      <D.26355>:
      match = match + 1;
      <D.26356>:
      <D.26353>:
      if (match == 0) goto <D.26357>; else goto <D.26358>;
      <D.26357>:
      // predicted unlikely by continue predictor.
      goto <D.22766>;
      <D.26358>:
      if (name != 0B) goto <D.26359>; else goto <D.26360>;
      <D.26359>:
      D.26243 = method->name;
      D.26361 = compare_func (name, D.26243);
      if (D.26361 != 0) goto <D.26362>; else goto <D.26363>;
      <D.26362>:
      // predicted unlikely by continue predictor.
      goto <D.22766>;
      <D.26363>:
      <D.26360>:
      match = 0;
      monoeg_g_ptr_array_add (array, method);
      <D.22766>:
      method = mono_class_get_methods (klass, &iter);
      if (method != 0B) goto <D.22785>; else goto <D.22786>;
      <D.22786>:
      D.26364 = bflags & 2;
      if (D.26364 == 0) goto <D.26365>; else goto <D.26366>;
      <D.26365>:
      klass = klass->parent;
      if (klass != 0B) goto handle_parent; else goto <D.26367>;
      <D.26367>:
      <D.26366>:
      if (&method_slots_default != method_slots) goto <D.26368>; else goto <D.26369>;
      <D.26368>:
      monoeg_g_free (method_slots);
      <D.26369>:
      D.26180 = array;
      return D.26180;
      loader_error:
      if (&method_slots_default != method_slots) goto <D.26370>; else goto <D.26371>;
      <D.26370>:
      monoeg_g_free (method_slots);
      <D.26371>:
      monoeg_g_ptr_array_free (array, 1);
      D.26181 = klass->exception_type;
      if (D.26181 != 0) goto <D.26372>; else goto <D.26373>;
      <D.26372>:
      D.26374 = mono_class_get_exception_for_failure (klass);
      *ex = D.26374;
      goto <D.26375>;
      <D.26373>:
      D.26376 = mono_loader_get_last_error ();
      D.26377 = mono_loader_error_prepare_exception (D.26376);
      *ex = D.26377;
      mono_loader_clear_error ();
      <D.26375>:
      D.26180 = 0B;
      return D.26180;
    }
  finally
    {
      iter = {CLOBBER};
      method_slots_default = {CLOBBER};
    }
}


is_generic_parameter (struct MonoType * type)
{
  MonoBoolean D.26380;
  int iftmp.6;
  long unsigned int D.26385;
  long unsigned int D.26386;
  unsigned char D.26388;

  D.26385 = BIT_FIELD_REF <*type, 64, 64>;
  D.26386 = D.26385 & 1073741824;
  if (D.26386 == 0) goto <D.26387>; else goto <D.26382>;
  <D.26387>:
  D.26388 = type->type;
  if (D.26388 == 19) goto <D.26383>; else goto <D.26389>;
  <D.26389>:
  D.26388 = type->type;
  if (D.26388 == 30) goto <D.26383>; else goto <D.26382>;
  <D.26383>:
  iftmp.6 = 1;
  goto <D.26384>;
  <D.26382>:
  iftmp.6 = 0;
  <D.26384>:
  D.26380 = (MonoBoolean) iftmp.6;
  return D.26380;
}


memset (void * __dest, int __ch, size_t __len)
{
  int D.26393;
  int D.26398;
  void * D.26400;
  long unsigned int D.26401;

  D.26393 = __builtin_constant_p (__len);
  if (D.26393 != 0) goto <D.26394>; else goto <D.26395>;
  <D.26394>:
  if (__len == 0) goto <D.26396>; else goto <D.26397>;
  <D.26396>:
  D.26398 = __builtin_constant_p (__ch);
  if (D.26398 == 0) goto <D.26391>; else goto <D.26399>;
  <D.26399>:
  if (__ch != 0) goto <D.26391>; else goto <D.26392>;
  <D.26391>:
  __warn_memset_zero_len ();
  D.26400 = __dest;
  return D.26400;
  <D.26392>:
  <D.26397>:
  <D.26395>:
  D.26401 = __builtin_object_size (__dest, 0);
  D.26400 = __builtin___memset_chk (__dest, __ch, __len, D.26401);
  return D.26400;
}


method_nonpublic (struct MonoMethod * method, gboolean start_klass)
{
  short unsigned int D.26403;
  int D.26404;
  int D.26405;
  gboolean D.26406;
  int iftmp.7;
  struct MonoClass * D.26412;

  D.26403 = method->flags;
  D.26404 = (int) D.26403;
  D.26405 = D.26404 & 7;
  switch (D.26405) <default: <D.22734>, case 1: <D.22732>, case 3: <D.22731>, case 6: <D.22733>>
  <D.22731>:
  if (start_klass != 0) goto <D.26408>; else goto <D.26411>;
  <D.26411>:
  D.26412 = mono_defaults.generic_ilist_class;
  if (D.26412 != 0B) goto <D.26408>; else goto <D.26409>;
  <D.26408>:
  iftmp.7 = 1;
  goto <D.26410>;
  <D.26409>:
  iftmp.7 = 0;
  <D.26410>:
  D.26406 = iftmp.7;
  return D.26406;
  <D.22732>:
  D.26406 = start_klass;
  return D.26406;
  <D.22733>:
  D.26406 = 0;
  return D.26406;
  <D.22734>:
  D.26406 = 1;
  return D.26406;
}


ves_icall_System_Environment_get_UserName ()
{
  struct MonoString * D.26414;
  struct MonoDomain * D.26415;
  const gchar * D.26416;

  D.26415 = mono_domain_get ();
  D.26416 = monoeg_g_get_user_name ();
  D.26414 = mono_string_new (D.26415, D.26416);
  return D.26414;
}


mono_icall_init ()
{
  int D.25816;
  short unsigned int D.26422;
  sizetype D.26423;
  const char * D.26424;
  const struct IcallTypeDesc * D.26427;
  short unsigned int D.26428;
  int D.26429;
  short unsigned int D.26430;
  int D.26431;
  int D.26432;
  short unsigned int D.26433;
  sizetype D.26434;
  int D.25826;
  struct GHashTable * icall_hash.8;
  int i;

  i = 0;
  if (1 != 0) goto <D.26418>; else goto <D.26419>;
  <D.26418>:
  {
    int j;
    const char * prev_class;
    const char * prev_method;

    prev_class = 0B;
    i = 0;
    goto <D.25831>;
    <D.25830>:
    {
      const struct IcallTypeDesc * desc;
      int num_icalls;

      prev_method = 0B;
      if (prev_class != 0B) goto <D.26420>; else goto <D.26421>;
      <D.26420>:
      {
        size_t __s1_len;
        size_t __s2_len;

        D.26422 = icall_type_names_idx[i];
        D.26423 = (sizetype) D.26422;
        D.26424 = &icall_type_names_str + D.26423;
        D.25816 = __builtin_strcmp (prev_class, D.26424);
      }
      if (D.25816 >= 0) goto <D.26425>; else goto <D.26426>;
      <D.26425>:
      D.26422 = icall_type_names_idx[i];
      D.26423 = (sizetype) D.26422;
      D.26424 = &icall_type_names_str + D.26423;
      monoeg_g_print ("class %s should come before class %s\n", D.26424, prev_class);
      <D.26426>:
      <D.26421>:
      D.26422 = icall_type_names_idx[i];
      D.26423 = (sizetype) D.26422;
      prev_class = &icall_type_names_str + D.26423;
      desc = &icall_type_descs[i];
      D.26427 = desc + 2;
      D.26428 = D.26427->first_icall;
      D.26429 = (int) D.26428;
      D.26430 = desc->first_icall;
      D.26431 = (int) D.26430;
      num_icalls = D.26429 - D.26431;
      j = 0;
      goto <D.25828>;
      <D.25827>:
      {
        const char * methodn;

        D.26430 = desc->first_icall;
        D.26431 = (int) D.26430;
        D.26432 = D.26431 + j;
        D.26433 = icall_names_idx[D.26432];
        D.26434 = (sizetype) D.26433;
        methodn = &icall_names_str + D.26434;
        if (prev_method != 0B) goto <D.26435>; else goto <D.26436>;
        <D.26435>:
        {
          size_t __s1_len;
          size_t __s2_len;

          D.25826 = __builtin_strcmp (prev_method, methodn);
        }
        if (D.25826 >= 0) goto <D.26437>; else goto <D.26438>;
        <D.26437>:
        monoeg_g_print ("method %s should come before method %s\n", methodn, prev_method);
        <D.26438>:
        <D.26436>:
        prev_method = methodn;
      }
      j = j + 1;
      <D.25828>:
      if (j < num_icalls) goto <D.25827>; else goto <D.25829>;
      <D.25829>:
    }
    i = i + 1;
    <D.25831>:
    if (i <= 107) goto <D.25830>; else goto <D.25832>;
    <D.25832>:
  }
  <D.26419>:
  icall_hash.8 = monoeg_g_hash_table_new_full (monoeg_g_str_hash, monoeg_g_str_equal, monoeg_g_free, 0B);
  icall_hash = icall_hash.8;
  pthread_mutex_init (&icall_mutex, 0B);
}


mono_icall_cleanup ()
{
  struct GHashTable * icall_hash.9;
  struct GHashTable * jit_icall_hash_name.10;
  struct GHashTable * jit_icall_hash_addr.11;

  icall_hash.9 = icall_hash;
  monoeg_g_hash_table_destroy (icall_hash.9);
  jit_icall_hash_name.10 = jit_icall_hash_name;
  monoeg_g_hash_table_destroy (jit_icall_hash_name.10);
  jit_icall_hash_addr.11 = jit_icall_hash_addr;
  monoeg_g_hash_table_destroy (jit_icall_hash_addr.11);
  pthread_mutex_destroy (&icall_mutex);
}


mono_add_internal_call (const char * name, const void * method)
{
  struct GHashTable * icall_hash.12;
  gchar * D.26444;

  mono_icall_lock ();
  icall_hash.12 = icall_hash;
  D.26444 = monoeg_strdup (name);
  monoeg_g_hash_table_insert_replace (icall_hash.12, D.26444, method, 0);
  mono_icall_unlock ();
}


mono_icall_lock ()
{
  pthread_mutex_lock (&icall_mutex);
}


monoeg_strdup (const gchar * str)
{
  gchar * D.26447;

  if (str != 0B) goto <D.26445>; else goto <D.26446>;
  <D.26445>:
  D.26447 = __strdup (str);
  return D.26447;
  <D.26446>:
  D.26447 = 0B;
  return D.26447;
}


mono_icall_unlock ()
{
  pthread_mutex_unlock (&icall_mutex);
}


mono_lookup_internal_call (struct MonoMethod * method)
{
  _Bool D.26449;
  long int D.26450;
  long int D.26451;
  long unsigned int D.26454;
  long unsigned int D.26455;
  struct MonoClass * D.26458;
  struct MonoClass * D.26459;
  void * D.26464;
  int pos.13;
  sizetype D.26466;
  char * D.26467;
  unsigned int pos.14;
  unsigned int D.26469;
  int D.26470;
  int D.26476;
  const char * D.26477;
  long unsigned int D.26478;
  sizetype D.26479;
  sizetype D.26480;
  char * D.26481;
  long unsigned int D.26482;
  sizetype D.26483;
  sizetype D.26484;
  sizetype D.26485;
  struct MonoMethodSignature * D.26486;
  long unsigned int D.26487;
  int D.26488;
  int D.26489;
  int D.26490;
  unsigned int D.26491;
  char * D.26494;
  long unsigned int D.26495;
  sizetype D.26496;
  sizetype D.26497;
  char * D.26498;
  sizetype D.26499;
  char * D.26500;
  struct GHashTable * icall_hash.15;
  sizetype D.26508;
  char * D.26509;
  struct MonoImage * D.26514;
  char * D.26515;
  char * sigstart;
  char * tmpsig;
  char mname[2048];
  int typelen;
  int mlen;
  int siglen;
  void * res;
  const struct IcallTypeDesc * imap;

  try
    {
      typelen = 0;
      imap = 0B;
      D.26449 = method == 0B;
      D.26450 = (long int) D.26449;
      D.26451 = __builtin_expect (D.26450, 0);
      if (D.26451 != 0) goto <D.26452>; else goto <D.26453>;
      <D.26452>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "icall.c", 8049, "method != NULL");
      <D.26453>:
      D.26454 = BIT_FIELD_REF <*method, 64, 256>;
      D.26455 = D.26454 & 4096;
      if (D.26455 != 0) goto <D.26456>; else goto <D.26457>;
      <D.26456>:
      method = MEM[(struct MonoMethodInflated *)method].declaring;
      <D.26457>:
      D.26458 = method->klass;
      D.26459 = D.26458->nested_in;
      if (D.26459 != 0B) goto <D.26460>; else goto <D.26461>;
      <D.26460>:
      {
        int pos;

        D.26458 = method->klass;
        D.26459 = D.26458->nested_in;
        pos = concat_class_name (&mname, 2046, D.26459);
        if (pos == 0) goto <D.26462>; else goto <D.26463>;
        <D.26462>:
        D.26464 = 0B;
        return D.26464;
        <D.26463>:
        pos.13 = pos;
        pos = pos.13 + 1;
        mname[pos.13] = 47;
        mname[pos] = 0;
        D.26466 = (sizetype) pos;
        D.26467 = &mname + D.26466;
        pos.14 = (unsigned int) pos;
        D.26469 = 2047 - pos.14;
        D.26470 = (int) D.26469;
        D.26458 = method->klass;
        typelen = concat_class_name (D.26467, D.26470, D.26458);
        if (typelen == 0) goto <D.26471>; else goto <D.26472>;
        <D.26471>:
        D.26464 = 0B;
        return D.26464;
        <D.26472>:
        typelen = typelen + pos;
      }
      goto <D.26473>;
      <D.26461>:
      D.26458 = method->klass;
      typelen = concat_class_name (&mname, 2048, D.26458);
      if (typelen == 0) goto <D.26474>; else goto <D.26475>;
      <D.26474>:
      D.26464 = 0B;
      return D.26464;
      <D.26475>:
      <D.26473>:
      imap = find_class_icalls (&mname);
      mname[typelen] = 58;
      D.26476 = typelen + 1;
      mname[D.26476] = 58;
      D.26477 = method->name;
      D.26478 = strlen (D.26477);
      mlen = (int) D.26478;
      D.26479 = (sizetype) typelen;
      D.26480 = D.26479 + 2;
      D.26481 = &mname + D.26480;
      D.26477 = method->name;
      D.26482 = (long unsigned int) mlen;
      memcpy (D.26481, D.26477, D.26482);
      D.26479 = (sizetype) typelen;
      D.26483 = (sizetype) mlen;
      D.26484 = D.26479 + D.26483;
      D.26485 = D.26484 + 2;
      sigstart = &mname + D.26485;
      *sigstart = 0;
      D.26486 = mono_method_signature (method);
      tmpsig = mono_signature_get_desc (D.26486, 1);
      D.26487 = strlen (tmpsig);
      siglen = (int) D.26487;
      D.26488 = typelen + mlen;
      D.26489 = D.26488 + siglen;
      D.26490 = D.26489 + 6;
      D.26491 = (unsigned int) D.26490;
      if (D.26491 > 2048) goto <D.26492>; else goto <D.26493>;
      <D.26492>:
      D.26464 = 0B;
      return D.26464;
      <D.26493>:
      *sigstart = 40;
      D.26494 = sigstart + 1;
      D.26495 = (long unsigned int) siglen;
      memcpy (D.26494, tmpsig, D.26495);
      D.26496 = (sizetype) siglen;
      D.26497 = D.26496 + 1;
      D.26498 = sigstart + D.26497;
      *D.26498 = 41;
      D.26496 = (sizetype) siglen;
      D.26499 = D.26496 + 2;
      D.26500 = sigstart + D.26499;
      *D.26500 = 0;
      monoeg_g_free (tmpsig);
      mono_icall_lock ();
      icall_hash.15 = icall_hash;
      res = monoeg_g_hash_table_lookup (icall_hash.15, &mname);
      if (res != 0B) goto <D.26502>; else goto <D.26503>;
      <D.26502>:
      mono_icall_unlock ();
      D.26464 = res;
      return D.26464;
      <D.26503>:
      *sigstart = 0;
      icall_hash.15 = icall_hash;
      res = monoeg_g_hash_table_lookup (icall_hash.15, &mname);
      if (res != 0B) goto <D.26504>; else goto <D.26505>;
      <D.26504>:
      mono_icall_unlock ();
      D.26464 = res;
      return D.26464;
      <D.26505>:
      if (imap == 0B) goto <D.26506>; else goto <D.26507>;
      <D.26506>:
      mono_icall_unlock ();
      D.26464 = 0B;
      return D.26464;
      <D.26507>:
      D.26483 = (sizetype) mlen;
      D.26508 = -D.26483;
      D.26509 = sigstart + D.26508;
      res = find_method_icall (imap, D.26509);
      if (res != 0B) goto <D.26510>; else goto <D.26511>;
      <D.26510>:
      mono_icall_unlock ();
      D.26464 = res;
      return D.26464;
      <D.26511>:
      *sigstart = 40;
      D.26483 = (sizetype) mlen;
      D.26508 = -D.26483;
      D.26509 = sigstart + D.26508;
      res = find_method_icall (imap, D.26509);
      if (res != 0B) goto <D.26512>; else goto <D.26513>;
      <D.26512>:
      mono_icall_unlock ();
      D.26464 = res;
      return D.26464;
      <D.26513>:
      monoeg_g_log (0B, 16, "cant resolve internal call to \"%s\" (tested without signature also)", &mname);
      monoeg_g_print ("\nYour mono runtime and class libraries are out of sync.\n");
      D.26458 = method->klass;
      D.26514 = D.26458->image;
      D.26515 = D.26514->name;
      monoeg_g_print ("The out of sync library is: %s\n", D.26515);
      monoeg_g_print ("\nWhen you update one from svn you need to update, compile and install\nthe other too.\n");
      monoeg_g_print ("Do not report this as a bug unless you\'re sure you have updated correctly:\nyou probably have a broken mono install.\n");
      monoeg_g_print ("If you see other errors or faults after this message they are probably related\n");
      monoeg_g_print ("and you need to fix your mono install first.\n");
      mono_icall_unlock ();
      D.26464 = 0B;
      return D.26464;
    }
  finally
    {
      mname = {CLOBBER};
    }
}


concat_class_name (char * buf, int bufsize, struct MonoClass * klass)
{
  const char * D.26518;
  long unsigned int D.26519;
  const char * D.26520;
  long unsigned int D.26521;
  int D.26522;
  int D.26523;
  int D.26526;
  long unsigned int D.26529;
  int nspacelen.16;
  sizetype D.26531;
  char * D.26532;
  sizetype D.26533;
  char * D.26534;
  long unsigned int D.26535;
  sizetype D.26536;
  char * D.26537;
  int nspacelen;
  int cnamelen;

  D.26518 = klass->name_space;
  D.26519 = strlen (D.26518);
  nspacelen = (int) D.26519;
  D.26520 = klass->name;
  D.26521 = strlen (D.26520);
  cnamelen = (int) D.26521;
  D.26522 = nspacelen + cnamelen;
  D.26523 = D.26522 + 1;
  if (D.26523 >= bufsize) goto <D.26524>; else goto <D.26525>;
  <D.26524>:
  D.26526 = 0;
  return D.26526;
  <D.26525>:
  if (nspacelen != 0) goto <D.26527>; else goto <D.26528>;
  <D.26527>:
  D.26518 = klass->name_space;
  D.26529 = (long unsigned int) nspacelen;
  memcpy (buf, D.26518, D.26529);
  nspacelen.16 = nspacelen;
  nspacelen = nspacelen.16 + 1;
  D.26531 = (sizetype) nspacelen.16;
  D.26532 = buf + D.26531;
  *D.26532 = 46;
  <D.26528>:
  D.26533 = (sizetype) nspacelen;
  D.26534 = buf + D.26533;
  D.26520 = klass->name;
  D.26535 = (long unsigned int) cnamelen;
  memcpy (D.26534, D.26520, D.26535);
  D.26522 = nspacelen + cnamelen;
  D.26536 = (sizetype) D.26522;
  D.26537 = buf + D.26536;
  *D.26537 = 0;
  D.26526 = nspacelen + cnamelen;
  return D.26526;
}


find_class_icalls (const char * name)
{
  const struct IcallTypeDesc * D.26541;
  long int nameslot.17;
  long int D.26543;
  long int D.26544;
  long int D.26545;
  const guint16 * nameslot;

  nameslot = mono_binary_search (name, &icall_type_names_idx, 108, 2, compare_class_imap);
  if (nameslot == 0B) goto <D.26539>; else goto <D.26540>;
  <D.26539>:
  D.26541 = 0B;
  return D.26541;
  <D.26540>:
  nameslot.17 = (long int) nameslot;
  D.26543 = (long int) &icall_type_names_idx[0];
  D.26544 = nameslot.17 - D.26543;
  D.26545 = D.26544 /[ex] 2;
  D.26541 = &icall_type_descs[D.26545];
  return D.26541;
}


compare_class_imap (const void * key, const void * elem)
{
  short unsigned int D.26547;
  sizetype D.26548;
  int D.26549;
  int D.25878;
  const char * class_name;

  D.26547 = MEM[(guint16 *)elem];
  D.26548 = (sizetype) D.26547;
  class_name = &icall_type_names_str + D.26548;
  {
    size_t __s1_len;
    size_t __s2_len;

    D.25878 = __builtin_strcmp (key, class_name);
  }
  D.26549 = D.25878;
  return D.26549;
}


memcpy (void * restrict __dest, const void * restrict __src, size_t __len)
{
  void * D.26551;
  long unsigned int D.26552;

  D.26552 = __builtin_object_size (__dest, 0);
  D.26551 = __builtin___memcpy_chk (__dest, __src, __len, D.26552);
  return D.26551;
}


find_method_icall (const struct IcallTypeDesc * imap, const char * name)
{
  short unsigned int D.26554;
  long unsigned int D.26555;
  long unsigned int D.26556;
  const void * D.26557;
  const struct IcallTypeDesc * D.26558;
  short unsigned int D.26559;
  int D.26560;
  int D.26561;
  int D.26562;
  long unsigned int D.26563;
  void * D.26566;
  long int nameslot.18;
  long int D.26568;
  long int D.26569;
  long int D.26570;
  const guint16 * nameslot;

  D.26554 = imap->first_icall;
  D.26555 = (long unsigned int) D.26554;
  D.26556 = D.26555 * 2;
  D.26557 = &icall_names_idx + D.26556;
  D.26558 = imap + 2;
  D.26559 = D.26558->first_icall;
  D.26560 = (int) D.26559;
  D.26554 = imap->first_icall;
  D.26561 = (int) D.26554;
  D.26562 = D.26560 - D.26561;
  D.26563 = (long unsigned int) D.26562;
  nameslot = mono_binary_search (name, D.26557, D.26563, 2, compare_method_imap);
  if (nameslot == 0B) goto <D.26564>; else goto <D.26565>;
  <D.26564>:
  D.26566 = 0B;
  return D.26566;
  <D.26565>:
  nameslot.18 = (long int) nameslot;
  D.26568 = (long int) &icall_names_idx[0];
  D.26569 = nameslot.18 - D.26568;
  D.26570 = D.26569 /[ex] 2;
  D.26566 = icall_functions[D.26570];
  return D.26566;
}


ves_icall_get_resources_ptr (struct MonoReflectionAssembly * assembly, void * * result, gint32 * size)
{
  gboolean D.26576;
  struct MonoAssembly * D.26577;
  unsigned int D.26580;
  char * D.26581;
  void * D.26582;
  unsigned int D.26585;
  int D.26586;
  struct MonoPEResourceDataEntry * entry;
  struct MonoImage * image;

  if (assembly == 0B) goto <D.26572>; else goto <D.26574>;
  <D.26574>:
  if (result == 0B) goto <D.26572>; else goto <D.26575>;
  <D.26575>:
  if (size == 0B) goto <D.26572>; else goto <D.26573>;
  <D.26572>:
  D.26576 = 0;
  return D.26576;
  <D.26573>:
  *result = 0B;
  *size = 0;
  D.26577 = assembly->assembly;
  image = D.26577->image;
  entry = mono_image_lookup_resource (image, 101, 0, 0B);
  if (entry == 0B) goto <D.26578>; else goto <D.26579>;
  <D.26578>:
  D.26576 = 0;
  return D.26576;
  <D.26579>:
  D.26580 = entry->rde_data_offset;
  D.26581 = mono_image_rva_map (image, D.26580);
  *result = D.26581;
  D.26582 = *result;
  if (D.26582 == 0B) goto <D.26583>; else goto <D.26584>;
  <D.26583>:
  monoeg_g_free (entry);
  D.26576 = 0;
  return D.26576;
  <D.26584>:
  D.26585 = entry->rde_size;
  D.26586 = (int) D.26585;
  *size = D.26586;
  monoeg_g_free (entry);
  D.26576 = 1;
  return D.26576;
}


ves_icall_System_Web_Util_ICalls_get_machine_install_dir ()
{
  const char * D.26588;
  struct MonoDomain * D.26589;
  struct MonoString * D.26590;
  struct MonoString * ipath;
  gchar * path;

  D.26588 = mono_get_config_dir ();
  path = monoeg_g_path_get_dirname (D.26588);
  D.26589 = mono_domain_get ();
  ipath = mono_string_new (D.26589, path);
  monoeg_g_free (path);
  D.26590 = ipath;
  return D.26590;
}


ves_icall_System_ValueType_InternalGetHashCode (struct MonoObject * this, struct MonoArray * * fields)
{
  struct MonoVTable * D.26592;
  int D.26593;
  gint32 D.26596;
  struct MonoType * D.26597;
  short unsigned int D.26598;
  int D.26599;
  int D.26600;
  int D.26603;
  int D.21626;
  int iftmp.19;
  int D.21625;
  const char[9] * D.26609;
  unsigned char D.26610;
  int D.26611;
  unsigned char D.26612;
  int D.26613;
  const unsigned char * D.26618;
  unsigned char D.26619;
  int D.26620;
  const unsigned char * D.26621;
  unsigned char D.26622;
  int D.26623;
  const unsigned char * D.26628;
  unsigned char D.26629;
  int D.26630;
  const unsigned char * D.26631;
  unsigned char D.26632;
  int D.26633;
  const unsigned char * D.26638;
  unsigned char D.26639;
  int D.26640;
  const unsigned char * D.26641;
  unsigned char D.26642;
  int D.26643;
  const char * D.26645;
  unsigned char D.26648;
  int D.26649;
  int D.26650;
  sizetype D.26651;
  gint32 * D.26652;
  int D.26653;
  struct MonoString * * D.26654;
  unsigned int D.26657;
  unsigned int result.20;
  unsigned int D.26659;
  int D.26662;
  long unsigned int D.26663;
  long unsigned int D.26664;
  struct MonoDomain * D.26665;
  int count.21;
  long unsigned int D.26667;
  long unsigned int D.26668;
  struct MonoObject * * D.26669;
  struct MonoDomain * D.26672;
  struct MonoClass * D.26673;
  long unsigned int D.26674;
  struct MonoArray * D.26675;
  struct MonoArray * D.26676;
  long unsigned int D.26677;
  long unsigned int D.26678;
  long unsigned int D.26679;
  struct MonoObject * * D.26680;
  struct MonoObject * D.26681;
  struct MonoClass * klass;
  struct MonoObject * * values;
  struct MonoObject * o;
  int count;
  gint32 result;
  struct MonoClassField * field;
  void * iter;

  try
    {
      values = 0B;
      count = 0;
      result = 0;
      D.26592 = this->vtable;
      klass = D.26592->klass;
      D.26593 = mono_class_num_fields (klass);
      if (D.26593 == 0) goto <D.26594>; else goto <D.26595>;
      <D.26594>:
      D.26596 = mono_object_hash (this);
      return D.26596;
      <D.26595>:
      iter = 0B;
      goto <D.21617>;
      <D.21632>:
      D.26597 = field->type;
      D.26598 = D.26597->attrs;
      D.26599 = (int) D.26598;
      D.26600 = D.26599 & 16;
      if (D.26600 != 0) goto <D.26601>; else goto <D.26602>;
      <D.26601>:
      // predicted unlikely by continue predictor.
      goto <D.21617>;
      <D.26602>:
      D.26597 = field->type;
      D.26598 = D.26597->attrs;
      D.26599 = (int) D.26598;
      D.26603 = D.26599 & 1536;
      if (D.26603 != 0) goto <D.26604>; else goto <D.26605>;
      <D.26604>:
      {
        size_t __s1_len;
        size_t __s2_len;

        __s2_len = 8;
        if (__s2_len <= 3) goto <D.26607>; else goto <D.26608>;
        <D.26607>:
        {
          const unsigned char * __s2;
          int __result;

          __s2 = mono_field_get_name (field);
          D.26609 = "_Deleted";
          D.26610 = MEM[(const unsigned char *)D.26609];
          D.26611 = (int) D.26610;
          D.26612 = *__s2;
          D.26613 = (int) D.26612;
          __result = D.26611 - D.26613;
          {
            if (__s2_len != 0) goto <D.26614>; else goto <D.26615>;
            <D.26614>:
            if (__result == 0) goto <D.26616>; else goto <D.26617>;
            <D.26616>:
            D.26618 = &MEM[(void *)"_Deleted" + 1B];
            D.26619 = *D.26618;
            D.26620 = (int) D.26619;
            D.26621 = __s2 + 1;
            D.26622 = *D.26621;
            D.26623 = (int) D.26622;
            __result = D.26620 - D.26623;
            if (__s2_len > 1) goto <D.26624>; else goto <D.26625>;
            <D.26624>:
            if (__result == 0) goto <D.26626>; else goto <D.26627>;
            <D.26626>:
            D.26628 = &MEM[(void *)"_Deleted" + 2B];
            D.26629 = *D.26628;
            D.26630 = (int) D.26629;
            D.26631 = __s2 + 2;
            D.26632 = *D.26631;
            D.26633 = (int) D.26632;
            __result = D.26630 - D.26633;
            if (__s2_len > 2) goto <D.26634>; else goto <D.26635>;
            <D.26634>:
            if (__result == 0) goto <D.26636>; else goto <D.26637>;
            <D.26636>:
            D.26638 = &MEM[(void *)"_Deleted" + 3B];
            D.26639 = *D.26638;
            D.26640 = (int) D.26639;
            D.26641 = __s2 + 3;
            D.26642 = *D.26641;
            D.26643 = (int) D.26642;
            __result = D.26640 - D.26643;
            <D.26637>:
            <D.26635>:
            <D.26627>:
            <D.26625>:
            <D.26617>:
            <D.26615>:
          }
          D.21625 = __result;
        }
        iftmp.19 = -D.21625;
        goto <D.26644>;
        <D.26608>:
        D.26645 = mono_field_get_name (field);
        iftmp.19 = __builtin_strcmp (D.26645, "_Deleted");
        <D.26644>:
        D.21626 = iftmp.19;
      }
      if (D.21626 == 0) goto <D.26646>; else goto <D.26647>;
      <D.26646>:
      // predicted unlikely by continue predictor.
      goto <D.21617>;
      <D.26647>:
      <D.26605>:
      D.26597 = field->type;
      D.26648 = D.26597->type;
      D.26649 = (int) D.26648;
      switch (D.26649) <default: <D.21631>, case 8: <D.21627>, case 14: <D.21629>>
      <D.21627>:
      D.26650 = field->offset;
      D.26651 = (sizetype) D.26650;
      D.26652 = this + D.26651;
      D.26653 = *D.26652;
      result = D.26653 ^ result;
      goto <D.21628>;
      <D.21629>:
      {
        struct MonoString * s;

        D.26650 = field->offset;
        D.26651 = (sizetype) D.26650;
        D.26654 = this + D.26651;
        s = *D.26654;
        if (s != 0B) goto <D.26655>; else goto <D.26656>;
        <D.26655>:
        D.26657 = mono_string_hash (s);
        result.20 = (unsigned int) result;
        D.26659 = D.26657 ^ result.20;
        result = (gint32) D.26659;
        <D.26656>:
        goto <D.21628>;
      }
      <D.21631>:
      if (values == 0B) goto <D.26660>; else goto <D.26661>;
      <D.26660>:
      D.26662 = mono_class_num_fields (klass);
      D.26663 = (long unsigned int) D.26662;
      D.26664 = D.26663 * 8;
      values = __builtin_alloca (D.26664);
      <D.26661>:
      D.26592 = this->vtable;
      D.26665 = D.26592->domain;
      o = mono_field_get_value_object (D.26665, field, this);
      count.21 = count;
      count = count.21 + 1;
      D.26667 = (long unsigned int) count.21;
      D.26668 = D.26667 * 8;
      D.26669 = values + D.26668;
      *D.26669 = o;
      <D.21628>:
      <D.21617>:
      field = mono_class_get_fields (klass, &iter);
      if (field != 0B) goto <D.21632>; else goto <D.21633>;
      <D.21633>:
      if (values != 0B) goto <D.26670>; else goto <D.26671>;
      <D.26670>:
      {
        int i;

        D.26672 = mono_domain_get ();
        D.26673 = mono_defaults.object_class;
        D.26674 = (long unsigned int) count;
        D.26675 = mono_array_new (D.26672, D.26673, D.26674);
        mono_gc_wbarrier_generic_store (fields, D.26675);
        i = 0;
        goto <D.21637>;
        <D.21636>:
        {
          void * * __p;

          D.26676 = *fields;
          D.26677 = (long unsigned int) i;
          __p = mono_array_addr_with_size (D.26676, 8, D.26677);
          D.26676 = *fields;
          D.26678 = (long unsigned int) i;
          D.26679 = D.26678 * 8;
          D.26680 = values + D.26679;
          D.26681 = *D.26680;
          mono_gc_wbarrier_set_arrayref (D.26676, __p, D.26681);
        }
        i = i + 1;
        <D.21637>:
        if (i < count) goto <D.21636>; else goto <D.21638>;
        <D.21638>:
      }
      goto <D.26682>;
      <D.26671>:
      *fields = 0B;
      <D.26682>:
      D.26596 = result;
      return D.26596;
    }
  finally
    {
      iter = {CLOBBER};
    }
}


ves_icall_System_ValueType_Equals (struct MonoObject * this, struct MonoObject * that, struct MonoArray * * fields)
{
  _Bool D.26685;
  long int D.26686;
  long int D.26687;
  struct MonoVTable * D.26692;
  struct MonoVTable * D.26693;
  MonoBoolean D.26696;
  long unsigned int D.26697;
  long unsigned int D.26698;
  struct MonoType * D.26701;
  struct MonoType * D.26704;
  unsigned char D.26705;
  gint32 * D.26708;
  int D.26709;
  gint32 * D.26710;
  int D.26711;
  _Bool D.26712;
  struct MonoType * D.26713;
  short unsigned int D.26714;
  int D.26715;
  int D.26716;
  int D.26719;
  int D.21660;
  int iftmp.22;
  int D.21659;
  const char[9] * D.26725;
  unsigned char D.26726;
  int D.26727;
  unsigned char D.26728;
  int D.26729;
  const unsigned char * D.26734;
  unsigned char D.26735;
  int D.26736;
  const unsigned char * D.26737;
  unsigned char D.26738;
  int D.26739;
  const unsigned char * D.26744;
  unsigned char D.26745;
  int D.26746;
  const unsigned char * D.26747;
  unsigned char D.26748;
  int D.26749;
  const unsigned char * D.26754;
  unsigned char D.26755;
  int D.26756;
  const unsigned char * D.26757;
  unsigned char D.26758;
  int D.26759;
  const char * D.26761;
  unsigned char D.26764;
  int D.26765;
  int D.26766;
  sizetype D.26767;
  guint8 * D.26768;
  unsigned char D.26769;
  guint8 * D.26770;
  unsigned char D.26771;
  gint16 * D.26774;
  short int D.26775;
  gint16 * D.26776;
  short int D.26777;
  gint32 * D.26780;
  int D.26781;
  gint32 * D.26782;
  int D.26783;
  gint64 * D.26786;
  long int D.26787;
  gint64 * D.26788;
  long int D.26789;
  float * D.26792;
  float D.26793;
  float * D.26794;
  float D.26795;
  double * D.26798;
  double D.26799;
  double * D.26800;
  double D.26801;
  struct MonoString * * D.26804;
  struct MonoString * * D.26805;
  int D.26810;
  int D.26811;
  mono_unichar2 * D.26814;
  mono_unichar2 * D.26815;
  long unsigned int D.26816;
  long unsigned int D.26817;
  int D.26818;
  int D.26823;
  int D.26824;
  long unsigned int D.26825;
  long unsigned int D.26826;
  struct MonoDomain * D.26827;
  int count.23;
  long unsigned int D.26829;
  long unsigned int D.26830;
  struct MonoObject * * D.26831;
  int count.24;
  long unsigned int D.26833;
  long unsigned int D.26834;
  struct MonoObject * * D.26835;
  struct MonoDomain * D.26839;
  struct MonoClass * D.26840;
  long unsigned int D.26841;
  struct MonoArray * D.26842;
  struct MonoArray * D.26843;
  sizetype D.26844;
  long unsigned int D.26845;
  long unsigned int D.26846;
  struct MonoObject * * D.26847;
  struct MonoObject * D.26848;
  struct MonoClass * klass;
  struct MonoObject * * values;
  struct MonoObject * o;
  struct MonoClassField * field;
  void * iter;
  int count;

  try
    {
      values = 0B;
      count = 0;
      D.26685 = that == 0B;
      D.26686 = (long int) D.26685;
      D.26687 = __builtin_expect (D.26686, 0);
      if (D.26687 != 0) goto <D.26688>; else goto <D.26689>;
      <D.26688>:
      {
        struct MonoException * ex;

        if (that != 0B) goto <D.26690>; else goto <D.26691>;
        <D.26690>:
        <D.26691>:
        ex = mono_get_exception_argument_null ("that");
        mono_raise_exception (ex);
      }
      <D.26689>:
      D.26692 = this->vtable;
      D.26693 = that->vtable;
      if (D.26692 != D.26693) goto <D.26694>; else goto <D.26695>;
      <D.26694>:
      D.26696 = 0;
      return D.26696;
      <D.26695>:
      D.26692 = this->vtable;
      klass = D.26692->klass;
      D.26697 = BIT_FIELD_REF <*klass, 64, 256>;
      D.26698 = D.26697 & 16;
      if (D.26698 != 0) goto <D.26699>; else goto <D.26700>;
      <D.26699>:
      D.26701 = mono_class_enum_basetype (klass);
      if (D.26701 != 0B) goto <D.26702>; else goto <D.26703>;
      <D.26702>:
      D.26704 = mono_class_enum_basetype (klass);
      D.26705 = D.26704->type;
      if (D.26705 == 8) goto <D.26706>; else goto <D.26707>;
      <D.26706>:
      D.26708 = this + 16;
      D.26709 = *D.26708;
      D.26710 = that + 16;
      D.26711 = *D.26710;
      D.26712 = D.26709 == D.26711;
      D.26696 = (MonoBoolean) D.26712;
      return D.26696;
      <D.26707>:
      <D.26703>:
      <D.26700>:
      *fields = 0B;
      iter = 0B;
      goto <D.21651>;
      <D.21681>:
      D.26713 = field->type;
      D.26714 = D.26713->attrs;
      D.26715 = (int) D.26714;
      D.26716 = D.26715 & 16;
      if (D.26716 != 0) goto <D.26717>; else goto <D.26718>;
      <D.26717>:
      // predicted unlikely by continue predictor.
      goto <D.21651>;
      <D.26718>:
      D.26713 = field->type;
      D.26714 = D.26713->attrs;
      D.26715 = (int) D.26714;
      D.26719 = D.26715 & 1536;
      if (D.26719 != 0) goto <D.26720>; else goto <D.26721>;
      <D.26720>:
      {
        size_t __s1_len;
        size_t __s2_len;

        __s2_len = 8;
        if (__s2_len <= 3) goto <D.26723>; else goto <D.26724>;
        <D.26723>:
        {
          const unsigned char * __s2;
          int __result;

          __s2 = mono_field_get_name (field);
          D.26725 = "_Deleted";
          D.26726 = MEM[(const unsigned char *)D.26725];
          D.26727 = (int) D.26726;
          D.26728 = *__s2;
          D.26729 = (int) D.26728;
          __result = D.26727 - D.26729;
          {
            if (__s2_len != 0) goto <D.26730>; else goto <D.26731>;
            <D.26730>:
            if (__result == 0) goto <D.26732>; else goto <D.26733>;
            <D.26732>:
            D.26734 = &MEM[(void *)"_Deleted" + 1B];
            D.26735 = *D.26734;
            D.26736 = (int) D.26735;
            D.26737 = __s2 + 1;
            D.26738 = *D.26737;
            D.26739 = (int) D.26738;
            __result = D.26736 - D.26739;
            if (__s2_len > 1) goto <D.26740>; else goto <D.26741>;
            <D.26740>:
            if (__result == 0) goto <D.26742>; else goto <D.26743>;
            <D.26742>:
            D.26744 = &MEM[(void *)"_Deleted" + 2B];
            D.26745 = *D.26744;
            D.26746 = (int) D.26745;
            D.26747 = __s2 + 2;
            D.26748 = *D.26747;
            D.26749 = (int) D.26748;
            __result = D.26746 - D.26749;
            if (__s2_len > 2) goto <D.26750>; else goto <D.26751>;
            <D.26750>:
            if (__result == 0) goto <D.26752>; else goto <D.26753>;
            <D.26752>:
            D.26754 = &MEM[(void *)"_Deleted" + 3B];
            D.26755 = *D.26754;
            D.26756 = (int) D.26755;
            D.26757 = __s2 + 3;
            D.26758 = *D.26757;
            D.26759 = (int) D.26758;
            __result = D.26756 - D.26759;
            <D.26753>:
            <D.26751>:
            <D.26743>:
            <D.26741>:
            <D.26733>:
            <D.26731>:
          }
          D.21659 = __result;
        }
        iftmp.22 = -D.21659;
        goto <D.26760>;
        <D.26724>:
        D.26761 = mono_field_get_name (field);
        iftmp.22 = __builtin_strcmp (D.26761, "_Deleted");
        <D.26760>:
        D.21660 = iftmp.22;
      }
      if (D.21660 == 0) goto <D.26762>; else goto <D.26763>;
      <D.26762>:
      // predicted unlikely by continue predictor.
      goto <D.21651>;
      <D.26763>:
      <D.26721>:
      D.26713 = field->type;
      D.26764 = D.26713->type;
      D.26765 = (int) D.26764;
      switch (D.26765) <default: <D.21679>, case 2: <D.21663>, case 3: <D.21667>, case 4: <D.21662>, case 5: <D.21661>, case 6: <D.21666>, case 7: <D.21665>, case 8: <D.21669>, case 9: <D.21668>, case 10: <D.21671>, case 11: <D.21670>, case 12: <D.21672>, case 13: <D.21673>, case 14: <D.21674>>
      <D.21661>:
      <D.21662>:
      <D.21663>:
      D.26766 = field->offset;
      D.26767 = (sizetype) D.26766;
      D.26768 = this + D.26767;
      D.26769 = *D.26768;
      D.26766 = field->offset;
      D.26767 = (sizetype) D.26766;
      D.26770 = that + D.26767;
      D.26771 = *D.26770;
      if (D.26769 != D.26771) goto <D.26772>; else goto <D.26773>;
      <D.26772>:
      D.26696 = 0;
      return D.26696;
      <D.26773>:
      goto <D.21664>;
      <D.21665>:
      <D.21666>:
      <D.21667>:
      D.26766 = field->offset;
      D.26767 = (sizetype) D.26766;
      D.26774 = this + D.26767;
      D.26775 = *D.26774;
      D.26766 = field->offset;
      D.26767 = (sizetype) D.26766;
      D.26776 = that + D.26767;
      D.26777 = *D.26776;
      if (D.26775 != D.26777) goto <D.26778>; else goto <D.26779>;
      <D.26778>:
      D.26696 = 0;
      return D.26696;
      <D.26779>:
      goto <D.21664>;
      <D.21668>:
      <D.21669>:
      D.26766 = field->offset;
      D.26767 = (sizetype) D.26766;
      D.26780 = this + D.26767;
      D.26781 = *D.26780;
      D.26766 = field->offset;
      D.26767 = (sizetype) D.26766;
      D.26782 = that + D.26767;
      D.26783 = *D.26782;
      if (D.26781 != D.26783) goto <D.26784>; else goto <D.26785>;
      <D.26784>:
      D.26696 = 0;
      return D.26696;
      <D.26785>:
      goto <D.21664>;
      <D.21670>:
      <D.21671>:
      D.26766 = field->offset;
      D.26767 = (sizetype) D.26766;
      D.26786 = this + D.26767;
      D.26787 = *D.26786;
      D.26766 = field->offset;
      D.26767 = (sizetype) D.26766;
      D.26788 = that + D.26767;
      D.26789 = *D.26788;
      if (D.26787 != D.26789) goto <D.26790>; else goto <D.26791>;
      <D.26790>:
      D.26696 = 0;
      return D.26696;
      <D.26791>:
      goto <D.21664>;
      <D.21672>:
      D.26766 = field->offset;
      D.26767 = (sizetype) D.26766;
      D.26792 = this + D.26767;
      D.26793 = *D.26792;
      D.26766 = field->offset;
      D.26767 = (sizetype) D.26766;
      D.26794 = that + D.26767;
      D.26795 = *D.26794;
      if (D.26793 != D.26795) goto <D.26796>; else goto <D.26797>;
      <D.26796>:
      D.26696 = 0;
      return D.26696;
      <D.26797>:
      goto <D.21664>;
      <D.21673>:
      D.26766 = field->offset;
      D.26767 = (sizetype) D.26766;
      D.26798 = this + D.26767;
      D.26799 = *D.26798;
      D.26766 = field->offset;
      D.26767 = (sizetype) D.26766;
      D.26800 = that + D.26767;
      D.26801 = *D.26800;
      if (D.26799 != D.26801) goto <D.26802>; else goto <D.26803>;
      <D.26802>:
      D.26696 = 0;
      return D.26696;
      <D.26803>:
      goto <D.21664>;
      <D.21674>:
      {
        struct MonoString * s1;
        struct MonoString * s2;
        guint32 s1len;
        guint32 s2len;

        D.26766 = field->offset;
        D.26767 = (sizetype) D.26766;
        D.26804 = this + D.26767;
        s1 = *D.26804;
        D.26766 = field->offset;
        D.26767 = (sizetype) D.26766;
        D.26805 = that + D.26767;
        s2 = *D.26805;
        if (s1 == s2) goto <D.21664>; else goto <D.26806>;
        <D.26806>:
        if (s1 == 0B) goto <D.26807>; else goto <D.26809>;
        <D.26809>:
        if (s2 == 0B) goto <D.26807>; else goto <D.26808>;
        <D.26807>:
        D.26696 = 0;
        return D.26696;
        <D.26808>:
        D.26810 = mono_string_length (s1);
        s1len = (guint32) D.26810;
        D.26811 = mono_string_length (s2);
        s2len = (guint32) D.26811;
        if (s1len != s2len) goto <D.26812>; else goto <D.26813>;
        <D.26812>:
        D.26696 = 0;
        return D.26696;
        <D.26813>:
        D.26814 = mono_string_chars (s1);
        D.26815 = mono_string_chars (s2);
        D.26816 = (long unsigned int) s1len;
        D.26817 = D.26816 * 2;
        D.26818 = memcmp (D.26814, D.26815, D.26817);
        if (D.26818 != 0) goto <D.26819>; else goto <D.26820>;
        <D.26819>:
        D.26696 = 0;
        return D.26696;
        <D.26820>:
        goto <D.21664>;
      }
      <D.21679>:
      if (values == 0B) goto <D.26821>; else goto <D.26822>;
      <D.26821>:
      D.26823 = mono_class_num_fields (klass);
      D.26824 = D.26823 * 2;
      D.26825 = (long unsigned int) D.26824;
      D.26826 = D.26825 * 8;
      values = __builtin_alloca (D.26826);
      <D.26822>:
      D.26692 = this->vtable;
      D.26827 = D.26692->domain;
      o = mono_field_get_value_object (D.26827, field, this);
      count.23 = count;
      count = count.23 + 1;
      D.26829 = (long unsigned int) count.23;
      D.26830 = D.26829 * 8;
      D.26831 = values + D.26830;
      *D.26831 = o;
      D.26692 = this->vtable;
      D.26827 = D.26692->domain;
      o = mono_field_get_value_object (D.26827, field, that);
      count.24 = count;
      count = count.24 + 1;
      D.26833 = (long unsigned int) count.24;
      D.26834 = D.26833 * 8;
      D.26835 = values + D.26834;
      *D.26835 = o;
      <D.21664>:
      D.26697 = BIT_FIELD_REF <*klass, 64, 256>;
      D.26698 = D.26697 & 16;
      if (D.26698 != 0) goto <D.21680>; else goto <D.26836>;
      <D.26836>:
      <D.21651>:
      field = mono_class_get_fields (klass, &iter);
      if (field != 0B) goto <D.21681>; else goto <D.21680>;
      <D.21680>:
      if (values != 0B) goto <D.26837>; else goto <D.26838>;
      <D.26837>:
      {
        int i;

        D.26839 = mono_domain_get ();
        D.26840 = mono_defaults.object_class;
        D.26841 = (long unsigned int) count;
        D.26842 = mono_array_new (D.26839, D.26840, D.26841);
        mono_gc_wbarrier_generic_store (fields, D.26842);
        i = 0;
        goto <D.21685>;
        <D.21684>:
        {
          void * * __p;

          D.26843 = *fields;
          D.26844 = (sizetype) i;
          __p = &D.26843->vector[D.26844];
          D.26843 = *fields;
          D.26845 = (long unsigned int) i;
          D.26846 = D.26845 * 8;
          D.26847 = values + D.26846;
          D.26848 = *D.26847;
          mono_gc_wbarrier_set_arrayref (D.26843, __p, D.26848);
        }
        i = i + 1;
        <D.21685>:
        if (i < count) goto <D.21684>; else goto <D.21686>;
        <D.21686>:
        D.26696 = 0;
        return D.26696;
      }
      <D.26838>:
      D.26696 = 1;
      return D.26696;
    }
  finally
    {
      iter = {CLOBBER};
    }
}


mono_TypedReference_ToObjectInternal (struct MonoType * type, void * value, struct MonoClass * klass)
{
  int D.26851;
  struct MonoObject * D.26854;
  struct MonoDomain * D.26855;

  D.26851 = mono_type_is_reference (type);
  if (D.26851 != 0) goto <D.26852>; else goto <D.26853>;
  <D.26852>:
  {
    struct MonoObject * * objp;

    objp = value;
    D.26854 = *objp;
    return D.26854;
  }
  <D.26853>:
  D.26855 = mono_domain_get ();
  D.26854 = mono_value_box (D.26855, klass, value);
  return D.26854;
}


mono_TypedReference_ToObject (struct MonoTypedRef tref)
{
  struct MonoType * D.26857;
  int D.26858;
  struct MonoObject * D.26861;
  struct MonoDomain * D.26862;
  struct MonoClass * D.26863;
  void * D.26864;

  D.26857 = tref.type;
  D.26858 = mono_type_is_reference (D.26857);
  if (D.26858 != 0) goto <D.26859>; else goto <D.26860>;
  <D.26859>:
  {
    struct MonoObject * * objp;

    objp = tref.value;
    D.26861 = *objp;
    return D.26861;
  }
  <D.26860>:
  D.26862 = mono_domain_get ();
  D.26863 = tref.klass;
  D.26864 = tref.value;
  D.26861 = mono_value_box (D.26862, D.26863, D.26864);
  return D.26861;
}


ves_icall_type_is_subtype_of (struct MonoReflectionType * type, struct MonoReflectionType * c, MonoBoolean check_interfaces)
{
  _Bool D.26866;
  long int D.26867;
  long int D.26868;
  struct MonoVTable * D.26871;
  guint32 D.26874;
  struct MonoType * D.26875;
  struct MonoType * D.26876;
  struct MonoClass * * D.26882;
  struct MonoClass * * D.26884;
  long unsigned int D.26885;
  long unsigned int D.26886;
  struct MonoClass * D.26889;
  _Bool D.26890;
  int D.26891;
  int D.26892;
  struct MonoDomain * domain;
  struct MonoClass * klass;
  struct MonoClass * klassc;

  D.26866 = type == 0B;
  D.26867 = (long int) D.26866;
  D.26868 = __builtin_expect (D.26867, 0);
  if (D.26868 != 0) goto <D.26869>; else goto <D.26870>;
  <D.26869>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "icall.c", 1502, "type != NULL");
  <D.26870>:
  D.26871 = MEM[(struct MonoObject *)type].vtable;
  domain = D.26871->domain;
  if (c == 0B) goto <D.26872>; else goto <D.26873>;
  <D.26872>:
  D.26874 = 0;
  return D.26874;
  <D.26873>:
  D.26875 = type->type;
  klass = mono_class_from_mono_type (D.26875);
  D.26876 = c->type;
  klassc = mono_class_from_mono_type (D.26876);
  if (check_interfaces != 0) goto <D.26877>; else goto <D.26878>;
  <D.26877>:
  mono_class_init_or_throw (klass);
  mono_class_init_or_throw (klassc);
  goto <D.26879>;
  <D.26878>:
  D.26882 = klass->supertypes;
  if (D.26882 == 0B) goto <D.26880>; else goto <D.26883>;
  <D.26883>:
  D.26884 = klassc->supertypes;
  if (D.26884 == 0B) goto <D.26880>; else goto <D.26881>;
  <D.26880>:
  mono_class_setup_supertypes (klass);
  mono_class_setup_supertypes (klassc);
  <D.26881>:
  <D.26879>:
  D.26875 = type->type;
  D.26885 = BIT_FIELD_REF <*D.26875, 64, 64>;
  D.26886 = D.26885 & 1073741824;
  if (D.26886 != 0) goto <D.26887>; else goto <D.26888>;
  <D.26887>:
  D.26889 = mono_defaults.object_class;
  D.26890 = D.26889 == klassc;
  D.26874 = (guint32) D.26890;
  return D.26874;
  <D.26888>:
  D.26891 = (int) check_interfaces;
  D.26892 = mono_class_is_subclass_of (klass, klassc, D.26891);
  D.26874 = (guint32) D.26892;
  return D.26874;
}


mono_class_init_or_throw (struct MonoClass * klass)
{
  int D.26894;
  struct MonoException * D.26897;

  D.26894 = mono_class_init (klass);
  if (D.26894 == 0) goto <D.26895>; else goto <D.26896>;
  <D.26895>:
  D.26897 = mono_class_get_exception_for_failure (klass);
  mono_raise_exception (D.26897);
  <D.26896>:
}


ves_icall_type_is_assignable_from (struct MonoReflectionType * type, struct MonoReflectionType * c)
{
  _Bool D.26898;
  long int D.26899;
  long int D.26900;
  struct MonoVTable * D.26903;
  struct MonoType * D.26904;
  struct MonoType * D.26905;
  long unsigned int D.26906;
  long unsigned int D.26907;
  long unsigned int D.26908;
  long unsigned int D.26909;
  guint32 D.26912;
  long unsigned int D.26913;
  int D.26916;
  int iftmp.25;
  int D.26922;
  int D.26924;
  int D.26925;
  unsigned char D.26929;
  int iftmp.26;
  unsigned char D.26934;
  struct MonoGenericParam * D.26936;
  short unsigned int D.26937;
  struct MonoGenericParam * D.26938;
  short unsigned int D.26939;
  _Bool D.26944;
  long unsigned int D.26948;
  long unsigned int D.26949;
  _Bool D.26952;
  long unsigned int D.26953;
  long unsigned int D.26954;
  long unsigned int D.26955;
  _Bool D.26956;
  int D.26957;
  struct MonoDomain * domain;
  struct MonoClass * klass;
  struct MonoClass * klassc;

  D.26898 = type == 0B;
  D.26899 = (long int) D.26898;
  D.26900 = __builtin_expect (D.26899, 0);
  if (D.26900 != 0) goto <D.26901>; else goto <D.26902>;
  <D.26901>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "icall.c", 1555, "type != NULL");
  <D.26902>:
  D.26903 = MEM[(struct MonoObject *)type].vtable;
  domain = D.26903->domain;
  D.26904 = type->type;
  klass = mono_class_from_mono_type (D.26904);
  D.26905 = c->type;
  klassc = mono_class_from_mono_type (D.26905);
  D.26904 = type->type;
  D.26906 = BIT_FIELD_REF <*D.26904, 64, 64>;
  D.26905 = c->type;
  D.26907 = BIT_FIELD_REF <*D.26905, 64, 64>;
  D.26908 = D.26906 ^ D.26907;
  D.26909 = D.26908 & 1073741824;
  if (D.26909 != 0) goto <D.26910>; else goto <D.26911>;
  <D.26910>:
  D.26912 = 0;
  return D.26912;
  <D.26911>:
  D.26904 = type->type;
  D.26906 = BIT_FIELD_REF <*D.26904, 64, 64>;
  D.26913 = D.26906 & 1073741824;
  if (D.26913 != 0) goto <D.26914>; else goto <D.26915>;
  <D.26914>:
  {
    struct MonoType * t;
    struct MonoType * ot;

    D.26904 = type->type;
    t = mono_type_get_underlying_type_ignore_byref (D.26904);
    D.26905 = c->type;
    ot = mono_type_get_underlying_type_ignore_byref (D.26905);
    klass = mono_class_from_mono_type (t);
    klassc = mono_class_from_mono_type (ot);
    D.26916 = mono_type_is_primitive (t);
    if (D.26916 != 0) goto <D.26917>; else goto <D.26918>;
    <D.26917>:
    D.26922 = mono_type_is_primitive (ot);
    if (D.26922 != 0) goto <D.26923>; else goto <D.26920>;
    <D.26923>:
    D.26924 = klass->instance_size;
    D.26925 = klassc->instance_size;
    if (D.26924 == D.26925) goto <D.26926>; else goto <D.26920>;
    <D.26926>:
    iftmp.25 = 1;
    goto <D.26921>;
    <D.26920>:
    iftmp.25 = 0;
    <D.26921>:
    D.26912 = (guint32) iftmp.25;
    return D.26912;
    <D.26918>:
    D.26929 = t->type;
    if (D.26929 == 19) goto <D.26927>; else goto <D.26930>;
    <D.26930>:
    D.26929 = t->type;
    if (D.26929 == 30) goto <D.26927>; else goto <D.26928>;
    <D.26927>:
    D.26929 = t->type;
    D.26934 = ot->type;
    if (D.26929 == D.26934) goto <D.26935>; else goto <D.26932>;
    <D.26935>:
    D.26936 = t->data.generic_param;
    D.26937 = D.26936->num;
    D.26938 = ot->data.generic_param;
    D.26939 = D.26938->num;
    if (D.26937 == D.26939) goto <D.26940>; else goto <D.26932>;
    <D.26940>:
    iftmp.26 = 1;
    goto <D.26933>;
    <D.26932>:
    iftmp.26 = 0;
    <D.26933>:
    D.26912 = (guint32) iftmp.26;
    return D.26912;
    <D.26928>:
    D.26929 = t->type;
    if (D.26929 == 15) goto <D.26941>; else goto <D.26943>;
    <D.26943>:
    D.26929 = t->type;
    if (D.26929 == 27) goto <D.26941>; else goto <D.26942>;
    <D.26941>:
    D.26929 = t->type;
    D.26934 = ot->type;
    D.26944 = D.26929 == D.26934;
    D.26912 = (guint32) D.26944;
    return D.26912;
    <D.26942>:
    D.26934 = ot->type;
    if (D.26934 == 19) goto <D.26945>; else goto <D.26947>;
    <D.26947>:
    D.26934 = ot->type;
    if (D.26934 == 30) goto <D.26945>; else goto <D.26946>;
    <D.26945>:
    D.26912 = 0;
    return D.26912;
    <D.26946>:
    D.26948 = BIT_FIELD_REF <*klass, 64, 256>;
    D.26949 = D.26948 & 8;
    if (D.26949 != 0) goto <D.26950>; else goto <D.26951>;
    <D.26950>:
    D.26952 = klass == klassc;
    D.26912 = (guint32) D.26952;
    return D.26912;
    <D.26951>:
    D.26948 = BIT_FIELD_REF <*klass, 64, 256>;
    D.26953 = BIT_FIELD_REF <*klassc, 64, 256>;
    D.26954 = D.26948 ^ D.26953;
    D.26955 = D.26954 & 8;
    D.26956 = D.26955 == 0;
    D.26912 = (guint32) D.26956;
    return D.26912;
  }
  <D.26915>:
  D.26957 = mono_class_is_assignable_from (klass, klassc);
  D.26912 = (guint32) D.26957;
  return D.26912;
}


mono_type_get_underlying_type_ignore_byref (struct MonoType * type)
{
  unsigned char D.26959;
  struct MonoClass * D.26962;
  long unsigned int D.26963;
  long unsigned int D.26964;
  struct MonoType * D.26967;
  struct MonoGenericClass * D.26970;
  struct MonoClass * D.26971;
  long unsigned int D.26972;
  long unsigned int D.26973;

  D.26959 = type->type;
  if (D.26959 == 17) goto <D.26960>; else goto <D.26961>;
  <D.26960>:
  D.26962 = type->data.klass;
  D.26963 = BIT_FIELD_REF <*D.26962, 64, 256>;
  D.26964 = D.26963 & 16;
  if (D.26964 != 0) goto <D.26965>; else goto <D.26966>;
  <D.26965>:
  D.26962 = type->data.klass;
  D.26967 = mono_class_enum_basetype (D.26962);
  return D.26967;
  <D.26966>:
  <D.26961>:
  D.26959 = type->type;
  if (D.26959 == 21) goto <D.26968>; else goto <D.26969>;
  <D.26968>:
  D.26970 = type->data.generic_class;
  D.26971 = D.26970->container_class;
  D.26972 = BIT_FIELD_REF <*D.26971, 64, 256>;
  D.26973 = D.26972 & 16;
  if (D.26973 != 0) goto <D.26974>; else goto <D.26975>;
  <D.26974>:
  D.26970 = type->data.generic_class;
  D.26971 = D.26970->container_class;
  D.26967 = mono_class_enum_basetype (D.26971);
  return D.26967;
  <D.26975>:
  <D.26969>:
  D.26967 = type;
  return D.26967;
}


mono_type_is_primitive (struct MonoType * type)
{
  gboolean D.26977;
  int iftmp.27;
  unsigned char D.26982;
  unsigned char D.26983;

  D.26982 = type->type;
  D.26983 = D.26982 + 254;
  if (D.26983 <= 11) goto <D.26979>; else goto <D.26984>;
  <D.26984>:
  D.26982 = type->type;
  if (D.26982 == 24) goto <D.26979>; else goto <D.26985>;
  <D.26985>:
  D.26982 = type->type;
  if (D.26982 == 25) goto <D.26979>; else goto <D.26980>;
  <D.26979>:
  iftmp.27 = 1;
  goto <D.26981>;
  <D.26980>:
  iftmp.27 = 0;
  <D.26981>:
  D.26977 = iftmp.27;
  return D.26977;
}


ves_icall_Type_make_byref_type (struct MonoReflectionType * type)
{
  struct MonoType * D.26987;
  struct MonoReflectionType * D.26988;
  struct MonoVTable * D.26989;
  struct MonoDomain * D.26990;
  struct MonoType * D.26991;
  struct MonoClass * klass;

  D.26987 = type->type;
  klass = mono_class_from_mono_type (D.26987);
  mono_class_init_or_throw (klass);
  check_for_invalid_type (klass);
  D.26989 = MEM[(struct MonoObject *)type].vtable;
  D.26990 = D.26989->domain;
  D.26991 = &klass->this_arg;
  D.26988 = mono_type_get_object (D.26990, D.26991);
  return D.26988;
}


check_for_invalid_type (struct MonoClass * klass)
{
  unsigned char D.26993;
  struct MonoDomain * D.26996;
  struct MonoException * D.26997;
  char * name;
  struct MonoString * str;

  D.26993 = klass->byval_arg.type;
  if (D.26993 != 22) goto <D.26994>; else goto <D.26995>;
  <D.26994>:
  return;
  <D.26995>:
  name = mono_type_get_full_name (klass);
  D.26996 = mono_domain_get ();
  str = mono_string_new (D.26996, name);
  monoeg_g_free (name);
  D.26997 = mono_get_exception_type_load (str, 0B);
  mono_raise_exception (D.26997);
}


ves_icall_Type_make_array_type (struct MonoReflectionType * type, int rank)
{
  struct MonoType * D.26999;
  unsigned int rank.28;
  struct MonoReflectionType * D.27004;
  struct MonoVTable * D.27005;
  struct MonoDomain * D.27006;
  struct MonoType * D.27007;
  struct MonoClass * klass;
  struct MonoClass * aklass;

  D.26999 = type->type;
  klass = mono_class_from_mono_type (D.26999);
  check_for_invalid_type (klass);
  if (rank == 0) goto <D.27000>; else goto <D.27001>;
  <D.27000>:
  aklass = mono_array_class_get (klass, 1);
  goto <D.27002>;
  <D.27001>:
  rank.28 = (unsigned int) rank;
  aklass = mono_bounded_array_class_get (klass, rank.28, 1);
  <D.27002>:
  D.27005 = MEM[(struct MonoObject *)type].vtable;
  D.27006 = D.27005->domain;
  D.27007 = &aklass->byval_arg;
  D.27004 = mono_type_get_object (D.27006, D.27007);
  return D.27004;
}


ves_icall_type_from_name (struct MonoString * name, MonoBoolean throwOnError, MonoBoolean ignoreCase)
{
  struct MonoReflectionType * D.27015;
  char * str;
  struct MonoReflectionType * type;

  str = mono_string_to_utf8 (name);
  type = type_from_name (str, ignoreCase);
  monoeg_g_free (str);
  if (type == 0B) goto <D.27009>; else goto <D.27010>;
  <D.27009>:
  {
    struct MonoException * e;

    e = 0B;
    if (throwOnError != 0) goto <D.27011>; else goto <D.27012>;
    <D.27011>:
    e = mono_get_exception_type_load (name, 0B);
    <D.27012>:
    mono_loader_clear_error ();
    if (e != 0B) goto <D.27013>; else goto <D.27014>;
    <D.27013>:
    mono_raise_exception (e);
    <D.27014>:
  }
  <D.27010>:
  D.27015 = type;
  return D.27015;
}


type_from_name (const char * str, MonoBoolean ignoreCase)
{
  int D.27017;
  struct MonoReflectionType * D.27020;
  const char * D.27021;
  struct MonoMethod * dest.29;
  struct MonoClass * D.27030;
  struct MonoImage * D.27031;
  struct MonoImage * D.27035;
  int D.27036;
  int type_resolve.30;
  struct MonoDomain * D.27050;
  struct MonoType * type;
  struct MonoAssembly * assembly;
  struct MonoTypeNameParse info;
  char * temp_str;
  gboolean type_resolve;

  try
    {
      type = 0B;
      assembly = 0B;
      temp_str = monoeg_strdup (str);
      type_resolve = 0;
      D.27017 = mono_reflection_parse_type (temp_str, &info);
      if (D.27017 == 0) goto <D.27018>; else goto <D.27019>;
      <D.27018>:
      mono_reflection_free_type_info (&info);
      monoeg_g_free (temp_str);
      D.27020 = 0B;
      return D.27020;
      <D.27019>:
      D.27021 = info.assembly.name;
      if (D.27021 != 0B) goto <D.27022>; else goto <D.27023>;
      <D.27022>:
      assembly = mono_assembly_load (&info.assembly, 0B, 0B);
      goto <D.27024>;
      <D.27023>:
      {
        struct MonoMethod * m;
        struct MonoMethod * dest;

        try
          {
            m = mono_method_get_last_managed ();
            dest = m;
            mono_stack_walk_no_il (get_caller_no_reflection, &dest);
            dest.29 = dest;
            if (dest.29 == 0B) goto <D.27026>; else goto <D.27027>;
            <D.27026>:
            dest = m;
            <D.27027>:
            dest.29 = dest;
            if (dest.29 != 0B) goto <D.27028>; else goto <D.27029>;
            <D.27028>:
            dest.29 = dest;
            D.27030 = dest.29->klass;
            D.27031 = D.27030->image;
            assembly = D.27031->assembly;
            type_resolve = 1;
            goto <D.27032>;
            <D.27029>:
            monoeg_g_log (0B, 16, "icall.c:1303:");
            <D.27032>:
          }
        finally
          {
            dest = {CLOBBER};
          }
      }
      <D.27024>:
      if (assembly != 0B) goto <D.27033>; else goto <D.27034>;
      <D.27033>:
      D.27035 = assembly->image;
      D.27036 = (int) ignoreCase;
      type = mono_reflection_get_type (D.27035, &info, D.27036, &type_resolve);
      <D.27034>:
      D.27021 = info.assembly.name;
      if (D.27021 == 0B) goto <D.27037>; else goto <D.27038>;
      <D.27037>:
      if (type == 0B) goto <D.27039>; else goto <D.27040>;
      <D.27039>:
      D.27036 = (int) ignoreCase;
      type = mono_reflection_get_type (0B, &info, D.27036, &type_resolve);
      <D.27040>:
      <D.27038>:
      if (assembly != 0B) goto <D.27041>; else goto <D.27042>;
      <D.27041>:
      if (type == 0B) goto <D.27043>; else goto <D.27044>;
      <D.27043>:
      type_resolve.30 = type_resolve;
      if (type_resolve.30 != 0) goto <D.27046>; else goto <D.27047>;
      <D.27046>:
      type_resolve = 0;
      D.27035 = assembly->image;
      D.27036 = (int) ignoreCase;
      type = mono_reflection_get_type (D.27035, &info, D.27036, &type_resolve);
      <D.27047>:
      <D.27044>:
      <D.27042>:
      mono_reflection_free_type_info (&info);
      monoeg_g_free (temp_str);
      if (type == 0B) goto <D.27048>; else goto <D.27049>;
      <D.27048>:
      D.27020 = 0B;
      return D.27020;
      <D.27049>:
      D.27050 = mono_domain_get ();
      D.27020 = mono_type_get_object (D.27050, type);
      return D.27020;
    }
  finally
    {
      info = {CLOBBER};
      type_resolve = {CLOBBER};
    }
}


get_caller_no_reflection (struct MonoMethod * m, gint32 no, gint32 ilo, gboolean managed, void * data)
{
  gboolean D.27055;
  long unsigned int D.27056;
  long unsigned int D.27057;
  struct MonoClass * D.27060;
  struct MonoImage * D.27061;
  struct MonoImage * D.27062;
  int D.21759;
  int iftmp.31;
  int D.21758;
  const char[18] * D.27068;
  unsigned char D.27069;
  int D.27070;
  unsigned char D.27071;
  int D.27072;
  const unsigned char * D.27077;
  unsigned char D.27078;
  int D.27079;
  const unsigned char * D.27080;
  unsigned char D.27081;
  int D.27082;
  const unsigned char * D.27087;
  unsigned char D.27088;
  int D.27089;
  const unsigned char * D.27090;
  unsigned char D.27091;
  int D.27092;
  const unsigned char * D.27097;
  unsigned char D.27098;
  int D.27099;
  const unsigned char * D.27100;
  unsigned char D.27101;
  int D.27102;
  const char * D.27104;
  struct MonoMethod * D.27107;
  struct MonoMethod * * dest;

  dest = data;
  if (managed == 0) goto <D.27053>; else goto <D.27054>;
  <D.27053>:
  D.27055 = 0;
  return D.27055;
  <D.27054>:
  D.27056 = BIT_FIELD_REF <*m, 64, 256>;
  D.27057 = D.27056 & 124;
  if (D.27057 != 0) goto <D.27058>; else goto <D.27059>;
  <D.27058>:
  D.27055 = 0;
  return D.27055;
  <D.27059>:
  D.27060 = m->klass;
  D.27061 = D.27060->image;
  D.27062 = mono_defaults.corlib;
  if (D.27061 == D.27062) goto <D.27063>; else goto <D.27064>;
  <D.27063>:
  {
    size_t __s1_len;
    size_t __s2_len;

    __s2_len = 17;
    if (__s2_len <= 3) goto <D.27066>; else goto <D.27067>;
    <D.27066>:
    {
      const unsigned char * __s2;
      int __result;

      D.27060 = m->klass;
      __s2 = D.27060->name_space;
      D.27068 = "System.Reflection";
      D.27069 = MEM[(const unsigned char *)D.27068];
      D.27070 = (int) D.27069;
      D.27071 = *__s2;
      D.27072 = (int) D.27071;
      __result = D.27070 - D.27072;
      {
        if (__s2_len != 0) goto <D.27073>; else goto <D.27074>;
        <D.27073>:
        if (__result == 0) goto <D.27075>; else goto <D.27076>;
        <D.27075>:
        D.27077 = &MEM[(void *)"System.Reflection" + 1B];
        D.27078 = *D.27077;
        D.27079 = (int) D.27078;
        D.27080 = __s2 + 1;
        D.27081 = *D.27080;
        D.27082 = (int) D.27081;
        __result = D.27079 - D.27082;
        if (__s2_len > 1) goto <D.27083>; else goto <D.27084>;
        <D.27083>:
        if (__result == 0) goto <D.27085>; else goto <D.27086>;
        <D.27085>:
        D.27087 = &MEM[(void *)"System.Reflection" + 2B];
        D.27088 = *D.27087;
        D.27089 = (int) D.27088;
        D.27090 = __s2 + 2;
        D.27091 = *D.27090;
        D.27092 = (int) D.27091;
        __result = D.27089 - D.27092;
        if (__s2_len > 2) goto <D.27093>; else goto <D.27094>;
        <D.27093>:
        if (__result == 0) goto <D.27095>; else goto <D.27096>;
        <D.27095>:
        D.27097 = &MEM[(void *)"System.Reflection" + 3B];
        D.27098 = *D.27097;
        D.27099 = (int) D.27098;
        D.27100 = __s2 + 3;
        D.27101 = *D.27100;
        D.27102 = (int) D.27101;
        __result = D.27099 - D.27102;
        <D.27096>:
        <D.27094>:
        <D.27086>:
        <D.27084>:
        <D.27076>:
        <D.27074>:
      }
      D.21758 = __result;
    }
    iftmp.31 = -D.21758;
    goto <D.27103>;
    <D.27067>:
    D.27060 = m->klass;
    D.27104 = D.27060->name_space;
    iftmp.31 = __builtin_strcmp (D.27104, "System.Reflection");
    <D.27103>:
    D.21759 = iftmp.31;
  }
  if (D.21759 == 0) goto <D.27105>; else goto <D.27106>;
  <D.27105>:
  D.27055 = 0;
  return D.27055;
  <D.27106>:
  <D.27064>:
  D.27107 = *dest;
  if (D.27107 == m) goto <D.27108>; else goto <D.27109>;
  <D.27108>:
  *dest = 0B;
  D.27055 = 0;
  return D.27055;
  <D.27109>:
  D.27107 = *dest;
  if (D.27107 == 0B) goto <D.27110>; else goto <D.27111>;
  <D.27110>:
  *dest = m;
  D.27055 = 1;
  return D.27055;
  <D.27111>:
  D.27055 = 0;
  return D.27055;
}


ves_icall_type_from_handle (struct MonoType * handle)
{
  struct MonoReflectionType * D.27113;
  struct MonoDomain * domain;

  domain = mono_domain_get ();
  D.27113 = mono_type_get_object (domain, handle);
  return D.27113;
}


ves_icall_Type_get_IsGenericTypeDefinition (struct MonoReflectionType * type)
{
  struct MonoVTable * D.27119;
  struct MonoClass * D.27120;
  struct MonoImage * D.27121;
  struct MonoImage * D.27122;
  struct MonoType * D.27124;
  gboolean D.27125;
  long unsigned int D.27126;
  long unsigned int D.27127;
  struct MonoGenericContainer * D.27130;
  _Bool D.27131;
  struct MonoClass * klass;

  if (type != 0B) goto <D.27117>; else goto <D.27118>;
  <D.27117>:
  D.27119 = MEM[(struct MonoObject *)type].vtable;
  D.27120 = D.27119->klass;
  D.27121 = D.27120->image;
  D.27122 = mono_defaults.corlib;
  if (D.27121 != D.27122) goto <D.27115>; else goto <D.27123>;
  <D.27123>:
  D.27124 = type->type;
  if (D.27124 == 0B) goto <D.27115>; else goto <D.27116>;
  <D.27115>:
  D.27125 = 0;
  return D.27125;
  <D.27116>:
  <D.27118>:
  D.27124 = type->type;
  D.27126 = BIT_FIELD_REF <*D.27124, 64, 64>;
  D.27127 = D.27126 & 1073741824;
  if (D.27127 != 0) goto <D.27128>; else goto <D.27129>;
  <D.27128>:
  D.27125 = 0;
  return D.27125;
  <D.27129>:
  D.27124 = type->type;
  klass = mono_class_from_mono_type (D.27124);
  D.27130 = klass->generic_container;
  D.27131 = D.27130 != 0B;
  D.27125 = (gboolean) D.27131;
  return D.27125;
}


ves_icall_Type_get_IsGenericType (struct MonoReflectionType * type)
{
  struct MonoVTable * D.27137;
  struct MonoClass * D.27138;
  struct MonoImage * D.27139;
  struct MonoImage * D.27140;
  struct MonoType * D.27142;
  gboolean D.27143;
  long unsigned int D.27144;
  long unsigned int D.27145;
  int iftmp.32;
  struct MonoGenericClass * D.27152;
  struct MonoGenericContainer * D.27154;
  struct MonoClass * klass;

  if (type != 0B) goto <D.27135>; else goto <D.27136>;
  <D.27135>:
  D.27137 = MEM[(struct MonoObject *)type].vtable;
  D.27138 = D.27137->klass;
  D.27139 = D.27138->image;
  D.27140 = mono_defaults.corlib;
  if (D.27139 != D.27140) goto <D.27133>; else goto <D.27141>;
  <D.27141>:
  D.27142 = type->type;
  if (D.27142 == 0B) goto <D.27133>; else goto <D.27134>;
  <D.27133>:
  D.27143 = 0;
  return D.27143;
  <D.27134>:
  <D.27136>:
  D.27142 = type->type;
  D.27144 = BIT_FIELD_REF <*D.27142, 64, 64>;
  D.27145 = D.27144 & 1073741824;
  if (D.27145 != 0) goto <D.27146>; else goto <D.27147>;
  <D.27146>:
  D.27143 = 0;
  return D.27143;
  <D.27147>:
  D.27142 = type->type;
  klass = mono_class_from_mono_type (D.27142);
  D.27152 = klass->generic_class;
  if (D.27152 != 0B) goto <D.27149>; else goto <D.27153>;
  <D.27153>:
  D.27154 = klass->generic_container;
  if (D.27154 != 0B) goto <D.27149>; else goto <D.27150>;
  <D.27149>:
  iftmp.32 = 1;
  goto <D.27151>;
  <D.27150>:
  iftmp.32 = 0;
  <D.27151>:
  D.27143 = iftmp.32;
  return D.27143;
}


ves_icall_Type_get_IsGenericInstance (struct MonoReflectionType * type)
{
  struct MonoType * D.27156;
  long unsigned int D.27157;
  long unsigned int D.27158;
  gboolean D.27161;
  struct MonoGenericClass * D.27162;
  _Bool D.27163;
  struct MonoClass * klass;

  D.27156 = type->type;
  D.27157 = BIT_FIELD_REF <*D.27156, 64, 64>;
  D.27158 = D.27157 & 1073741824;
  if (D.27158 != 0) goto <D.27159>; else goto <D.27160>;
  <D.27159>:
  D.27161 = 0;
  return D.27161;
  <D.27160>:
  D.27156 = type->type;
  klass = mono_class_from_mono_type (D.27156);
  D.27162 = klass->generic_class;
  D.27163 = D.27162 != 0B;
  D.27161 = (gboolean) D.27163;
  return D.27161;
}


ves_icall_Type_MakePointerType (struct MonoReflectionType * type)
{
  struct MonoType * D.27165;
  struct MonoReflectionType * D.27166;
  struct MonoVTable * D.27167;
  struct MonoDomain * D.27168;
  struct MonoType * D.27169;
  struct MonoClass * klass;
  struct MonoClass * pklass;

  D.27165 = type->type;
  klass = mono_class_from_mono_type (D.27165);
  mono_class_init_or_throw (klass);
  check_for_invalid_type (klass);
  D.27165 = type->type;
  pklass = mono_ptr_class_get (D.27165);
  D.27167 = MEM[(struct MonoObject *)type].vtable;
  D.27168 = D.27167->domain;
  D.27169 = &pklass->byval_arg;
  D.27166 = mono_type_get_object (D.27168, D.27169);
  return D.27166;
}


ves_icall_Type_MakeGenericType (struct MonoReflectionType * type, struct MonoArray * type_array)
{
  int iftmp.33;
  struct MonoVTable * D.27176;
  struct MonoClass * D.27177;
  struct MonoImage * D.27178;
  struct MonoImage * D.27179;
  struct MonoType * D.27181;
  _Bool D.27182;
  long int D.27183;
  long int D.27184;
  struct MonoClass * D.27187;
  long unsigned int D.27188;
  long unsigned int D.27189;
  long unsigned int D.27190;
  long unsigned int D.27191;
  char * D.27192;
  long unsigned int D.27193;
  long unsigned int D.27194;
  struct MonoType * * D.27195;
  struct MonoType * D.27196;
  struct MonoReflectionType * D.27199;
  struct MonoGenericClass * D.27200;
  int D.27203;
  struct MonoException * D.27206;
  struct MonoDomain * D.27207;
  struct MonoClass * class;
  struct MonoType * geninst;
  struct MonoType * * types;
  int i;
  int count;

  if (type != 0B) goto <D.27175>; else goto <D.27172>;
  <D.27175>:
  D.27176 = MEM[(struct MonoObject *)type].vtable;
  D.27177 = D.27176->klass;
  D.27178 = D.27177->image;
  D.27179 = mono_defaults.corlib;
  if (D.27178 != D.27179) goto <D.27173>; else goto <D.27180>;
  <D.27180>:
  D.27181 = type->type;
  if (D.27181 == 0B) goto <D.27173>; else goto <D.27172>;
  <D.27173>:
  iftmp.33 = 1;
  goto <D.27174>;
  <D.27172>:
  iftmp.33 = 0;
  <D.27174>:
  D.27182 = iftmp.33 != 0;
  D.27183 = (long int) D.27182;
  D.27184 = __builtin_expect (D.27183, 0);
  if (D.27184 != 0) goto <D.27185>; else goto <D.27186>;
  <D.27185>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "icall.c", 2404, "IS_MONOTYPE (type)");
  <D.27186>:
  D.27181 = type->type;
  D.27187 = mono_class_from_mono_type (D.27181);
  mono_class_init_or_throw (D.27187);
  D.27188 = mono_array_length (type_array);
  count = (int) D.27188;
  D.27189 = (long unsigned int) count;
  D.27190 = D.27189 * 8;
  types = monoeg_malloc0 (D.27190);
  i = 0;
  goto <D.22260>;
  <D.22259>:
  {
    struct MonoReflectionType * t;

    D.27191 = (long unsigned int) i;
    D.27192 = mono_array_addr_with_size (type_array, 8, D.27191);
    t = MEM[(void * *)D.27192];
    D.27193 = (long unsigned int) i;
    D.27194 = D.27193 * 8;
    D.27195 = types + D.27194;
    D.27196 = t->type;
    *D.27195 = D.27196;
  }
  i = i + 1;
  <D.22260>:
  if (i < count) goto <D.22259>; else goto <D.22261>;
  <D.22261>:
  geninst = mono_reflection_bind_generic_parameters (type, count, types);
  monoeg_g_free (types);
  if (geninst == 0B) goto <D.27197>; else goto <D.27198>;
  <D.27197>:
  D.27199 = 0B;
  return D.27199;
  <D.27198>:
  class = mono_class_from_mono_type (geninst);
  D.27200 = class->generic_class;
  if (D.27200 != 0B) goto <D.27201>; else goto <D.27202>;
  <D.27201>:
  D.27203 = mono_verifier_class_is_valid_generic_instantiation (class);
  if (D.27203 == 0) goto <D.27204>; else goto <D.27205>;
  <D.27204>:
  D.27206 = mono_get_exception_argument ("typeArguments", "Invalid generic arguments");
  mono_raise_exception (D.27206);
  <D.27205>:
  <D.27202>:
  D.27176 = MEM[(struct MonoObject *)type].vtable;
  D.27207 = D.27176->domain;
  D.27199 = mono_type_get_object (D.27207, geninst);
  return D.27199;
}


ves_icall_type_IsInstanceOfType (struct MonoReflectionType * type, struct MonoObject * obj)
{
  struct MonoType * D.27209;
  guint32 D.27210;
  struct MonoObject * D.27211;
  _Bool D.27212;
  struct MonoClass * klass;

  D.27209 = type->type;
  klass = mono_class_from_mono_type (D.27209);
  mono_class_init_or_throw (klass);
  D.27211 = mono_object_isinst (obj, klass);
  D.27212 = D.27211 != 0B;
  D.27210 = (guint32) D.27212;
  return D.27210;
}


ves_icall_Type_IsArrayImpl (struct MonoReflectionType * t)
{
  int iftmp.34;
  long unsigned int D.27218;
  long unsigned int D.27219;
  unsigned char D.27221;
  MonoBoolean D.27223;
  struct MonoType * type;
  MonoBoolean res;

  type = t->type;
  D.27218 = BIT_FIELD_REF <*type, 64, 64>;
  D.27219 = D.27218 & 1073741824;
  if (D.27219 == 0) goto <D.27220>; else goto <D.27215>;
  <D.27220>:
  D.27221 = type->type;
  if (D.27221 == 20) goto <D.27216>; else goto <D.27222>;
  <D.27222>:
  D.27221 = type->type;
  if (D.27221 == 29) goto <D.27216>; else goto <D.27215>;
  <D.27216>:
  iftmp.34 = 1;
  goto <D.27217>;
  <D.27215>:
  iftmp.34 = 0;
  <D.27217>:
  res = (MonoBoolean) iftmp.34;
  D.27223 = res;
  return D.27223;
}


ves_icall_type_GetTypeCodeInternal (struct MonoReflectionType * type)
{
  struct MonoType * D.27225;
  unsigned char D.27226;
  long unsigned int D.27227;
  long unsigned int D.27228;
  guint32 D.27231;
  long unsigned int D.27232;
  long unsigned int D.27233;
  struct MonoType * D.27236;
  unsigned char D.27237;
  struct MonoImage * D.27238;
  int D.27239;
  int D.21838;
  int iftmp.35;
  int D.21837;
  const char[7] * D.27245;
  unsigned char D.27246;
  int D.27247;
  unsigned char D.27248;
  int D.27249;
  const unsigned char * D.27254;
  unsigned char D.27255;
  int D.27256;
  const unsigned char * D.27257;
  unsigned char D.27258;
  int D.27259;
  const unsigned char * D.27264;
  unsigned char D.27265;
  int D.27266;
  const unsigned char * D.27267;
  unsigned char D.27268;
  int D.27269;
  const unsigned char * D.27274;
  unsigned char D.27275;
  int D.27276;
  const unsigned char * D.27277;
  unsigned char D.27278;
  int D.27279;
  const char * D.27281;
  int D.21847;
  int iftmp.36;
  int D.21846;
  const char[8] * D.27287;
  unsigned char D.27288;
  int D.27289;
  unsigned char D.27290;
  int D.27291;
  const unsigned char * D.27296;
  unsigned char D.27297;
  int D.27298;
  const unsigned char * D.27299;
  unsigned char D.27300;
  int D.27301;
  const unsigned char * D.27306;
  unsigned char D.27307;
  int D.27308;
  const unsigned char * D.27309;
  unsigned char D.27310;
  int D.27311;
  const unsigned char * D.27316;
  unsigned char D.27317;
  int D.27318;
  const unsigned char * D.27319;
  unsigned char D.27320;
  int D.27321;
  const char * D.27323;
  int D.21856;
  int iftmp.37;
  int D.21855;
  const char[9] * D.27329;
  unsigned char D.27330;
  int D.27331;
  unsigned char D.27332;
  int D.27333;
  const unsigned char * D.27338;
  unsigned char D.27339;
  int D.27340;
  const unsigned char * D.27341;
  unsigned char D.27342;
  int D.27343;
  const unsigned char * D.27348;
  unsigned char D.27349;
  int D.27350;
  const unsigned char * D.27351;
  unsigned char D.27352;
  int D.27353;
  const unsigned char * D.27358;
  unsigned char D.27359;
  int D.27360;
  const unsigned char * D.27361;
  unsigned char D.27362;
  int D.27363;
  struct MonoImage * D.27367;
  struct MonoImage * D.27368;
  int D.21874;
  int iftmp.38;
  int D.21873;
  unsigned char D.27374;
  int D.27375;
  const unsigned char * D.27380;
  unsigned char D.27381;
  int D.27382;
  const unsigned char * D.27387;
  unsigned char D.27388;
  int D.27389;
  const unsigned char * D.27394;
  unsigned char D.27395;
  int D.27396;
  const char * D.27398;
  int D.21883;
  int iftmp.39;
  int D.21882;
  const char[7] * D.27404;
  unsigned char D.27405;
  int D.27406;
  unsigned char D.27407;
  int D.27408;
  const unsigned char * D.27413;
  unsigned char D.27414;
  int D.27415;
  const unsigned char * D.27416;
  unsigned char D.27417;
  int D.27418;
  const unsigned char * D.27423;
  unsigned char D.27424;
  int D.27425;
  const unsigned char * D.27426;
  unsigned char D.27427;
  int D.27428;
  const unsigned char * D.27433;
  unsigned char D.27434;
  int D.27435;
  const unsigned char * D.27436;
  unsigned char D.27437;
  int D.27438;
  const char * D.27440;
  int t;
  void handle_enum = <<< error >>>;

  D.27225 = type->type;
  D.27226 = D.27225->type;
  t = (int) D.27226;
  D.27225 = type->type;
  D.27227 = BIT_FIELD_REF <*D.27225, 64, 64>;
  D.27228 = D.27227 & 1073741824;
  if (D.27228 != 0) goto <D.27229>; else goto <D.27230>;
  <D.27229>:
  D.27231 = 1;
  return D.27231;
  <D.27230>:
  handle_enum:
  switch (t) <default: <D.21885>, case 1: <D.21812>, case 2: <D.21813>, case 3: <D.21818>, case 4: <D.21815>, case 5: <D.21814>, case 6: <D.21817>, case 7: <D.21816>, case 8: <D.21823>, case 9: <D.21822>, case 10: <D.21825>, case 11: <D.21824>, case 12: <D.21826>, case 13: <D.21827>, case 14: <D.21857>, case 15: <D.21819>, case 17: <D.21828>, case 18: <D.21864>, case 19: <D.21861>, case 20: <D.21859>, case 21: <D.21884>, case 22: <D.21863>, case 24: <D.21821>, case 25: <D.21820>, case 28: <D.21860>, case 29: <D.21858>, case 30: <D.21862>>
  <D.21812>:
  D.27231 = 1;
  return D.27231;
  <D.21813>:
  D.27231 = 3;
  return D.27231;
  <D.21814>:
  D.27231 = 6;
  return D.27231;
  <D.21815>:
  D.27231 = 5;
  return D.27231;
  <D.21816>:
  D.27231 = 8;
  return D.27231;
  <D.21817>:
  D.27231 = 7;
  return D.27231;
  <D.21818>:
  D.27231 = 4;
  return D.27231;
  <D.21819>:
  <D.21820>:
  <D.21821>:
  D.27231 = 1;
  return D.27231;
  <D.21822>:
  D.27231 = 10;
  return D.27231;
  <D.21823>:
  D.27231 = 9;
  return D.27231;
  <D.21824>:
  D.27231 = 12;
  return D.27231;
  <D.21825>:
  D.27231 = 11;
  return D.27231;
  <D.21826>:
  D.27231 = 13;
  return D.27231;
  <D.21827>:
  D.27231 = 14;
  return D.27231;
  <D.21828>:
  {
    struct MonoClass * klass;

    D.27225 = type->type;
    klass = D.27225->data.klass;
    D.27232 = BIT_FIELD_REF <*klass, 64, 256>;
    D.27233 = D.27232 & 16;
    if (D.27233 != 0) goto <D.27234>; else goto <D.27235>;
    <D.27234>:
    D.27236 = mono_class_enum_basetype (klass);
    D.27237 = D.27236->type;
    t = (int) D.27237;
    goto handle_enum;
    <D.27235>:
    D.27238 = klass->image;
    D.27239 = mono_is_corlib_image (D.27238);
    if (D.27239 != 0) goto <D.27240>; else goto <D.27241>;
    <D.27240>:
    {
      size_t __s1_len;
      size_t __s2_len;

      __s2_len = 6;
      if (__s2_len <= 3) goto <D.27243>; else goto <D.27244>;
      <D.27243>:
      {
        const unsigned char * __s2;
        int __result;

        __s2 = klass->name_space;
        D.27245 = "System";
        D.27246 = MEM[(const unsigned char *)D.27245];
        D.27247 = (int) D.27246;
        D.27248 = *__s2;
        D.27249 = (int) D.27248;
        __result = D.27247 - D.27249;
        {
          if (__s2_len != 0) goto <D.27250>; else goto <D.27251>;
          <D.27250>:
          if (__result == 0) goto <D.27252>; else goto <D.27253>;
          <D.27252>:
          D.27254 = &MEM[(void *)"System" + 1B];
          D.27255 = *D.27254;
          D.27256 = (int) D.27255;
          D.27257 = __s2 + 1;
          D.27258 = *D.27257;
          D.27259 = (int) D.27258;
          __result = D.27256 - D.27259;
          if (__s2_len > 1) goto <D.27260>; else goto <D.27261>;
          <D.27260>:
          if (__result == 0) goto <D.27262>; else goto <D.27263>;
          <D.27262>:
          D.27264 = &MEM[(void *)"System" + 2B];
          D.27265 = *D.27264;
          D.27266 = (int) D.27265;
          D.27267 = __s2 + 2;
          D.27268 = *D.27267;
          D.27269 = (int) D.27268;
          __result = D.27266 - D.27269;
          if (__s2_len > 2) goto <D.27270>; else goto <D.27271>;
          <D.27270>:
          if (__result == 0) goto <D.27272>; else goto <D.27273>;
          <D.27272>:
          D.27274 = &MEM[(void *)"System" + 3B];
          D.27275 = *D.27274;
          D.27276 = (int) D.27275;
          D.27277 = __s2 + 3;
          D.27278 = *D.27277;
          D.27279 = (int) D.27278;
          __result = D.27276 - D.27279;
          <D.27273>:
          <D.27271>:
          <D.27263>:
          <D.27261>:
          <D.27253>:
          <D.27251>:
        }
        D.21837 = __result;
      }
      iftmp.35 = -D.21837;
      goto <D.27280>;
      <D.27244>:
      D.27281 = klass->name_space;
      iftmp.35 = __builtin_strcmp (D.27281, "System");
      <D.27280>:
      D.21838 = iftmp.35;
    }
    if (D.21838 == 0) goto <D.27282>; else goto <D.27283>;
    <D.27282>:
    {
      size_t __s1_len;
      size_t __s2_len;

      __s2_len = 7;
      if (__s2_len <= 3) goto <D.27285>; else goto <D.27286>;
      <D.27285>:
      {
        const unsigned char * __s2;
        int __result;

        __s2 = klass->name;
        D.27287 = "Decimal";
        D.27288 = MEM[(const unsigned char *)D.27287];
        D.27289 = (int) D.27288;
        D.27290 = *__s2;
        D.27291 = (int) D.27290;
        __result = D.27289 - D.27291;
        {
          if (__s2_len != 0) goto <D.27292>; else goto <D.27293>;
          <D.27292>:
          if (__result == 0) goto <D.27294>; else goto <D.27295>;
          <D.27294>:
          D.27296 = &MEM[(void *)"Decimal" + 1B];
          D.27297 = *D.27296;
          D.27298 = (int) D.27297;
          D.27299 = __s2 + 1;
          D.27300 = *D.27299;
          D.27301 = (int) D.27300;
          __result = D.27298 - D.27301;
          if (__s2_len > 1) goto <D.27302>; else goto <D.27303>;
          <D.27302>:
          if (__result == 0) goto <D.27304>; else goto <D.27305>;
          <D.27304>:
          D.27306 = &MEM[(void *)"Decimal" + 2B];
          D.27307 = *D.27306;
          D.27308 = (int) D.27307;
          D.27309 = __s2 + 2;
          D.27310 = *D.27309;
          D.27311 = (int) D.27310;
          __result = D.27308 - D.27311;
          if (__s2_len > 2) goto <D.27312>; else goto <D.27313>;
          <D.27312>:
          if (__result == 0) goto <D.27314>; else goto <D.27315>;
          <D.27314>:
          D.27316 = &MEM[(void *)"Decimal" + 3B];
          D.27317 = *D.27316;
          D.27318 = (int) D.27317;
          D.27319 = __s2 + 3;
          D.27320 = *D.27319;
          D.27321 = (int) D.27320;
          __result = D.27318 - D.27321;
          <D.27315>:
          <D.27313>:
          <D.27305>:
          <D.27303>:
          <D.27295>:
          <D.27293>:
        }
        D.21846 = __result;
      }
      iftmp.36 = -D.21846;
      goto <D.27322>;
      <D.27286>:
      D.27323 = klass->name;
      iftmp.36 = __builtin_strcmp (D.27323, "Decimal");
      <D.27322>:
      D.21847 = iftmp.36;
    }
    if (D.21847 == 0) goto <D.27324>; else goto <D.27325>;
    <D.27324>:
    D.27231 = 15;
    return D.27231;
    <D.27325>:
    {
      size_t __s1_len;
      size_t __s2_len;

      __s2_len = 8;
      if (__s2_len <= 3) goto <D.27327>; else goto <D.27328>;
      <D.27327>:
      {
        const unsigned char * __s2;
        int __result;

        __s2 = klass->name;
        D.27329 = "DateTime";
        D.27330 = MEM[(const unsigned char *)D.27329];
        D.27331 = (int) D.27330;
        D.27332 = *__s2;
        D.27333 = (int) D.27332;
        __result = D.27331 - D.27333;
        {
          if (__s2_len != 0) goto <D.27334>; else goto <D.27335>;
          <D.27334>:
          if (__result == 0) goto <D.27336>; else goto <D.27337>;
          <D.27336>:
          D.27338 = &MEM[(void *)"DateTime" + 1B];
          D.27339 = *D.27338;
          D.27340 = (int) D.27339;
          D.27341 = __s2 + 1;
          D.27342 = *D.27341;
          D.27343 = (int) D.27342;
          __result = D.27340 - D.27343;
          if (__s2_len > 1) goto <D.27344>; else goto <D.27345>;
          <D.27344>:
          if (__result == 0) goto <D.27346>; else goto <D.27347>;
          <D.27346>:
          D.27348 = &MEM[(void *)"DateTime" + 2B];
          D.27349 = *D.27348;
          D.27350 = (int) D.27349;
          D.27351 = __s2 + 2;
          D.27352 = *D.27351;
          D.27353 = (int) D.27352;
          __result = D.27350 - D.27353;
          if (__s2_len > 2) goto <D.27354>; else goto <D.27355>;
          <D.27354>:
          if (__result == 0) goto <D.27356>; else goto <D.27357>;
          <D.27356>:
          D.27358 = &MEM[(void *)"DateTime" + 3B];
          D.27359 = *D.27358;
          D.27360 = (int) D.27359;
          D.27361 = __s2 + 3;
          D.27362 = *D.27361;
          D.27363 = (int) D.27362;
          __result = D.27360 - D.27363;
          <D.27357>:
          <D.27355>:
          <D.27347>:
          <D.27345>:
          <D.27337>:
          <D.27335>:
        }
        D.21855 = __result;
      }
      iftmp.37 = -D.21855;
      goto <D.27364>;
      <D.27328>:
      D.27323 = klass->name;
      iftmp.37 = __builtin_strcmp (D.27323, "DateTime");
      <D.27364>:
      D.21856 = iftmp.37;
    }
    if (D.21856 == 0) goto <D.27365>; else goto <D.27366>;
    <D.27365>:
    D.27231 = 16;
    return D.27231;
    <D.27366>:
    <D.27283>:
    <D.27241>:
    D.27231 = 1;
    return D.27231;
  }
  <D.21857>:
  D.27231 = 18;
  return D.27231;
  <D.21858>:
  <D.21859>:
  <D.21860>:
  <D.21861>:
  <D.21862>:
  <D.21863>:
  D.27231 = 1;
  return D.27231;
  <D.21864>:
  {
    struct MonoClass * klass;

    D.27225 = type->type;
    klass = D.27225->data.klass;
    D.27367 = klass->image;
    D.27368 = mono_defaults.corlib;
    if (D.27367 == D.27368) goto <D.27369>; else goto <D.27370>;
    <D.27369>:
    {
      size_t __s1_len;
      size_t __s2_len;

      __s2_len = 6;
      if (__s2_len <= 3) goto <D.27372>; else goto <D.27373>;
      <D.27372>:
      {
        const unsigned char * __s2;
        int __result;

        __s2 = klass->name_space;
        D.27245 = "System";
        D.27246 = MEM[(const unsigned char *)D.27245];
        D.27247 = (int) D.27246;
        D.27374 = *__s2;
        D.27375 = (int) D.27374;
        __result = D.27247 - D.27375;
        {
          if (__s2_len != 0) goto <D.27376>; else goto <D.27377>;
          <D.27376>:
          if (__result == 0) goto <D.27378>; else goto <D.27379>;
          <D.27378>:
          D.27254 = &MEM[(void *)"System" + 1B];
          D.27255 = *D.27254;
          D.27256 = (int) D.27255;
          D.27380 = __s2 + 1;
          D.27381 = *D.27380;
          D.27382 = (int) D.27381;
          __result = D.27256 - D.27382;
          if (__s2_len > 1) goto <D.27383>; else goto <D.27384>;
          <D.27383>:
          if (__result == 0) goto <D.27385>; else goto <D.27386>;
          <D.27385>:
          D.27264 = &MEM[(void *)"System" + 2B];
          D.27265 = *D.27264;
          D.27266 = (int) D.27265;
          D.27387 = __s2 + 2;
          D.27388 = *D.27387;
          D.27389 = (int) D.27388;
          __result = D.27266 - D.27389;
          if (__s2_len > 2) goto <D.27390>; else goto <D.27391>;
          <D.27390>:
          if (__result == 0) goto <D.27392>; else goto <D.27393>;
          <D.27392>:
          D.27274 = &MEM[(void *)"System" + 3B];
          D.27275 = *D.27274;
          D.27276 = (int) D.27275;
          D.27394 = __s2 + 3;
          D.27395 = *D.27394;
          D.27396 = (int) D.27395;
          __result = D.27276 - D.27396;
          <D.27393>:
          <D.27391>:
          <D.27386>:
          <D.27384>:
          <D.27379>:
          <D.27377>:
        }
        D.21873 = __result;
      }
      iftmp.38 = -D.21873;
      goto <D.27397>;
      <D.27373>:
      D.27398 = klass->name_space;
      iftmp.38 = __builtin_strcmp (D.27398, "System");
      <D.27397>:
      D.21874 = iftmp.38;
    }
    if (D.21874 == 0) goto <D.27399>; else goto <D.27400>;
    <D.27399>:
    {
      size_t __s1_len;
      size_t __s2_len;

      __s2_len = 6;
      if (__s2_len <= 3) goto <D.27402>; else goto <D.27403>;
      <D.27402>:
      {
        const unsigned char * __s2;
        int __result;

        __s2 = klass->name;
        D.27404 = "DBNull";
        D.27405 = MEM[(const unsigned char *)D.27404];
        D.27406 = (int) D.27405;
        D.27407 = *__s2;
        D.27408 = (int) D.27407;
        __result = D.27406 - D.27408;
        {
          if (__s2_len != 0) goto <D.27409>; else goto <D.27410>;
          <D.27409>:
          if (__result == 0) goto <D.27411>; else goto <D.27412>;
          <D.27411>:
          D.27413 = &MEM[(void *)"DBNull" + 1B];
          D.27414 = *D.27413;
          D.27415 = (int) D.27414;
          D.27416 = __s2 + 1;
          D.27417 = *D.27416;
          D.27418 = (int) D.27417;
          __result = D.27415 - D.27418;
          if (__s2_len > 1) goto <D.27419>; else goto <D.27420>;
          <D.27419>:
          if (__result == 0) goto <D.27421>; else goto <D.27422>;
          <D.27421>:
          D.27423 = &MEM[(void *)"DBNull" + 2B];
          D.27424 = *D.27423;
          D.27425 = (int) D.27424;
          D.27426 = __s2 + 2;
          D.27427 = *D.27426;
          D.27428 = (int) D.27427;
          __result = D.27425 - D.27428;
          if (__s2_len > 2) goto <D.27429>; else goto <D.27430>;
          <D.27429>:
          if (__result == 0) goto <D.27431>; else goto <D.27432>;
          <D.27431>:
          D.27433 = &MEM[(void *)"DBNull" + 3B];
          D.27434 = *D.27433;
          D.27435 = (int) D.27434;
          D.27436 = __s2 + 3;
          D.27437 = *D.27436;
          D.27438 = (int) D.27437;
          __result = D.27435 - D.27438;
          <D.27432>:
          <D.27430>:
          <D.27422>:
          <D.27420>:
          <D.27412>:
          <D.27410>:
        }
        D.21882 = __result;
      }
      iftmp.39 = -D.21882;
      goto <D.27439>;
      <D.27403>:
      D.27440 = klass->name;
      iftmp.39 = __builtin_strcmp (D.27440, "DBNull");
      <D.27439>:
      D.21883 = iftmp.39;
    }
    if (D.21883 == 0) goto <D.27441>; else goto <D.27442>;
    <D.27441>:
    D.27231 = 2;
    return D.27231;
    <D.27442>:
    <D.27400>:
    <D.27370>:
  }
  D.27231 = 1;
  return D.27231;
  <D.21884>:
  D.27231 = 1;
  return D.27231;
  <D.21885>:
  monoeg_g_log (0B, 4, "type 0x%02x not handled in GetTypeCode()", t);
  <D.21886>:
  goto <D.21886>;
  D.27231 = 0;
  return D.27231;
}


ves_icall_Type_GetPacking (struct MonoReflectionType * type, guint32 * packing, guint32 * size)
{
  struct MonoType * D.27444;
  struct MonoImage * D.27445;
  long unsigned int D.27446;
  long unsigned int D.27447;
  int D.27450;
  unsigned int D.27451;
  int D.27452;
  unsigned int D.27453;
  unsigned int D.27455;
  struct MonoClass * klass;

  D.27444 = type->type;
  klass = mono_class_from_mono_type (D.27444);
  mono_class_init_or_throw (klass);
  D.27445 = klass->image;
  D.27446 = BIT_FIELD_REF <*D.27445, 64, 192>;
  D.27447 = D.27446 & 34359738368;
  if (D.27447 != 0) goto <D.27448>; else goto <D.27449>;
  <D.27448>:
  {
    struct MonoReflectionTypeBuilder * tb;

    tb = type;
    D.27450 = tb->packing_size;
    D.27451 = (unsigned int) D.27450;
    *packing = D.27451;
    D.27452 = tb->class_size;
    D.27453 = (unsigned int) D.27452;
    *size = D.27453;
  }
  goto <D.27454>;
  <D.27449>:
  D.27445 = klass->image;
  D.27455 = klass->type_token;
  mono_metadata_packing_from_typedef (D.27445, D.27455, packing, size);
  <D.27454>:
}


ves_icall_Type_GetInterfaceMapData (struct MonoReflectionType * type, struct MonoReflectionType * iface, struct MonoArray * * targets, struct MonoArray * * methods)
{
  struct MonoType * D.27456;
  struct MonoType * D.27457;
  struct MonoVTable * D.27460;
  struct MonoClass * D.27461;
  long unsigned int D.27462;
  struct MonoArray * D.27463;
  struct MonoArray * D.27464;
  struct MonoArray * D.27465;
  long unsigned int D.27466;
  struct MonoMethod * * D.27467;
  int D.27468;
  long unsigned int D.27469;
  long unsigned int D.27470;
  struct MonoMethod * * D.27471;
  struct MonoMethod * D.27472;
  struct MonoArray * D.27473;
  gboolean variance_used;
  struct MonoClass * class;
  struct MonoClass * iclass;
  struct MonoReflectionMethod * member;
  struct MonoMethod * method;
  void * iter;
  int i;
  int len;
  int ioffset;
  struct MonoDomain * domain;

  try
    {
      D.27456 = type->type;
      class = mono_class_from_mono_type (D.27456);
      D.27457 = iface->type;
      iclass = mono_class_from_mono_type (D.27457);
      i = 0;
      mono_class_init_or_throw (class);
      mono_class_init_or_throw (iclass);
      mono_class_setup_vtable (class);
      ioffset = mono_class_interface_offset_with_variance (class, iclass, &variance_used);
      if (ioffset == -1) goto <D.27458>; else goto <D.27459>;
      <D.27458>:
      return;
      <D.27459>:
      len = mono_class_num_methods (iclass);
      D.27460 = MEM[(struct MonoObject *)type].vtable;
      domain = D.27460->domain;
      D.27461 = mono_defaults.method_info_class;
      D.27462 = (long unsigned int) len;
      D.27463 = mono_array_new (domain, D.27461, D.27462);
      mono_gc_wbarrier_generic_store (targets, D.27463);
      D.27461 = mono_defaults.method_info_class;
      D.27462 = (long unsigned int) len;
      D.27464 = mono_array_new (domain, D.27461, D.27462);
      mono_gc_wbarrier_generic_store (methods, D.27464);
      iter = 0B;
      goto <D.22155>;
      <D.22154>:
      member = mono_method_get_object (domain, method, iclass);
      {
        void * * __p;

        D.27465 = *methods;
        D.27466 = (long unsigned int) i;
        __p = mono_array_addr_with_size (D.27465, 8, D.27466);
        D.27465 = *methods;
        mono_gc_wbarrier_set_arrayref (D.27465, __p, member);
      }
      D.27467 = class->vtable;
      D.27468 = i + ioffset;
      D.27469 = (long unsigned int) D.27468;
      D.27470 = D.27469 * 8;
      D.27471 = D.27467 + D.27470;
      D.27472 = *D.27471;
      member = mono_method_get_object (domain, D.27472, class);
      {
        void * * __p;

        D.27473 = *targets;
        D.27466 = (long unsigned int) i;
        __p = mono_array_addr_with_size (D.27473, 8, D.27466);
        D.27473 = *targets;
        mono_gc_wbarrier_set_arrayref (D.27473, __p, member);
      }
      i = i + 1;
      <D.22155>:
      method = mono_class_get_methods (iclass, &iter);
      if (method != 0B) goto <D.22154>; else goto <D.22156>;
      <D.22156>:
    }
  finally
    {
      variance_used = {CLOBBER};
      iter = {CLOBBER};
    }
}


ves_icall_Type_GetGenericTypeDefinition_impl (struct MonoReflectionType * type)
{
  struct MonoType * D.27477;
  long unsigned int D.27478;
  long unsigned int D.27479;
  struct MonoReflectionType * D.27482;
  struct MonoGenericContainer * D.27483;
  struct MonoGenericClass * D.27486;
  long unsigned int D.27490;
  long unsigned int D.27491;
  struct MonoVTable * D.27494;
  struct MonoDomain * D.27495;
  struct MonoType * D.27496;
  struct MonoClass * klass;

  D.27477 = type->type;
  D.27478 = BIT_FIELD_REF <*D.27477, 64, 64>;
  D.27479 = D.27478 & 1073741824;
  if (D.27479 != 0) goto <D.27480>; else goto <D.27481>;
  <D.27480>:
  D.27482 = 0B;
  return D.27482;
  <D.27481>:
  D.27477 = type->type;
  klass = mono_class_from_mono_type (D.27477);
  D.27483 = klass->generic_container;
  if (D.27483 != 0B) goto <D.27484>; else goto <D.27485>;
  <D.27484>:
  D.27482 = type;
  return D.27482;
  <D.27485>:
  D.27486 = klass->generic_class;
  if (D.27486 != 0B) goto <D.27487>; else goto <D.27488>;
  <D.27487>:
  {
    struct MonoClass * generic_class;
    void * tb;

    D.27486 = klass->generic_class;
    generic_class = D.27486->container_class;
    tb = mono_class_get_ref_info (generic_class);
    D.27490 = BIT_FIELD_REF <*generic_class, 64, 256>;
    D.27491 = D.27490 & 128;
    if (D.27491 != 0) goto <D.27492>; else goto <D.27489>;
    <D.27492>:
    if (tb != 0B) goto <D.27493>; else goto <D.27489>;
    <D.27493>:
    D.27482 = tb;
    return D.27482;
    <D.27489>:
    D.27494 = MEM[(struct MonoObject *)type].vtable;
    D.27495 = D.27494->domain;
    D.27496 = &generic_class->byval_arg;
    D.27482 = mono_type_get_object (D.27495, D.27496);
    return D.27482;
  }
  <D.27488>:
  D.27482 = 0B;
  return D.27482;
}


ves_icall_Type_GetGenericParameterPosition (struct MonoReflectionType * type)
{
  struct MonoVTable * D.27502;
  struct MonoClass * D.27503;
  struct MonoImage * D.27504;
  struct MonoImage * D.27505;
  struct MonoType * D.27507;
  gint32 D.27508;
  unsigned char D.27509;
  struct MonoGenericParam * D.27512;
  short unsigned int D.27513;

  if (type != 0B) goto <D.27500>; else goto <D.27501>;
  <D.27500>:
  D.27502 = MEM[(struct MonoObject *)type].vtable;
  D.27503 = D.27502->klass;
  D.27504 = D.27503->image;
  D.27505 = mono_defaults.corlib;
  if (D.27504 != D.27505) goto <D.27498>; else goto <D.27506>;
  <D.27506>:
  D.27507 = type->type;
  if (D.27507 == 0B) goto <D.27498>; else goto <D.27499>;
  <D.27498>:
  D.27508 = -1;
  return D.27508;
  <D.27499>:
  <D.27501>:
  D.27507 = type->type;
  D.27509 = is_generic_parameter (D.27507);
  if (D.27509 != 0) goto <D.27510>; else goto <D.27511>;
  <D.27510>:
  D.27507 = type->type;
  D.27512 = D.27507->data.generic_param;
  D.27513 = D.27512->num;
  D.27508 = (gint32) D.27513;
  return D.27508;
  <D.27511>:
  D.27508 = -1;
  return D.27508;
}


ves_icall_Type_GetGenericParameterConstraints (struct MonoReflectionType * type)
{
  int iftmp.40;
  struct MonoVTable * D.27520;
  struct MonoClass * D.27521;
  struct MonoImage * D.27522;
  struct MonoImage * D.27523;
  struct MonoType * D.27525;
  _Bool D.27526;
  long int D.27527;
  long int D.27528;
  struct MonoGenericParamInfo * iftmp.41;
  struct MonoGenericParam * D.27532;
  struct MonoGenericContainer * D.27533;
  struct MonoClass * D.27538;
  struct MonoClass * D.27539;
  long unsigned int D.27540;
  long unsigned int D.27541;
  struct MonoClass * * D.27542;
  long unsigned int D.27543;
  long unsigned int D.27544;
  struct MonoClass * * D.27545;
  struct MonoClass * D.27546;
  struct MonoType * D.27547;
  struct MonoReflectionType * D.27548;
  struct MonoArray * D.27549;
  struct MonoGenericParamInfo * param_info;
  struct MonoDomain * domain;
  struct MonoClass * * ptr;
  struct MonoArray * res;
  int i;
  int count;

  if (type != 0B) goto <D.27519>; else goto <D.27516>;
  <D.27519>:
  D.27520 = MEM[(struct MonoObject *)type].vtable;
  D.27521 = D.27520->klass;
  D.27522 = D.27521->image;
  D.27523 = mono_defaults.corlib;
  if (D.27522 != D.27523) goto <D.27517>; else goto <D.27524>;
  <D.27524>:
  D.27525 = type->type;
  if (D.27525 == 0B) goto <D.27517>; else goto <D.27516>;
  <D.27517>:
  iftmp.40 = 1;
  goto <D.27518>;
  <D.27516>:
  iftmp.40 = 0;
  <D.27518>:
  D.27526 = iftmp.40 != 0;
  D.27527 = (long int) D.27526;
  D.27528 = __builtin_expect (D.27527, 0);
  if (D.27528 != 0) goto <D.27529>; else goto <D.27530>;
  <D.27529>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "icall.c", 2493, "IS_MONOTYPE (type)");
  <D.27530>:
  D.27520 = MEM[(struct MonoObject *)type].vtable;
  domain = D.27520->domain;
  D.27525 = type->type;
  D.27532 = D.27525->data.generic_param;
  D.27533 = D.27532->owner;
  if (D.27533 != 0B) goto <D.27534>; else goto <D.27535>;
  <D.27534>:
  D.27525 = type->type;
  D.27532 = D.27525->data.generic_param;
  iftmp.41 = &MEM[(struct MonoGenericParamFull *)D.27532].info;
  goto <D.27536>;
  <D.27535>:
  iftmp.41 = 0B;
  <D.27536>:
  param_info = iftmp.41;
  count = 0;
  ptr = param_info->constraints;
  goto <D.22286>;
  <D.22285>:
  ptr = ptr + 8;
  count = count + 1;
  <D.22286>:
  if (ptr != 0B) goto <D.27537>; else goto <D.22287>;
  <D.27537>:
  D.27538 = *ptr;
  if (D.27538 != 0B) goto <D.22285>; else goto <D.22287>;
  <D.22287>:
  D.27539 = mono_defaults.monotype_class;
  D.27540 = (long unsigned int) count;
  res = mono_array_new (domain, D.27539, D.27540);
  i = 0;
  goto <D.22290>;
  <D.22289>:
  {
    void * * __p;

    D.27541 = (long unsigned int) i;
    __p = mono_array_addr_with_size (res, 8, D.27541);
    D.27542 = param_info->constraints;
    D.27543 = (long unsigned int) i;
    D.27544 = D.27543 * 8;
    D.27545 = D.27542 + D.27544;
    D.27546 = *D.27545;
    D.27547 = &D.27546->byval_arg;
    D.27548 = mono_type_get_object (domain, D.27547);
    mono_gc_wbarrier_set_arrayref (res, __p, D.27548);
  }
  i = i + 1;
  <D.22290>:
  if (i < count) goto <D.22289>; else goto <D.22291>;
  <D.22291>:
  D.27549 = res;
  return D.27549;
}


ves_icall_Type_GetGenericParameterAttributes (struct MonoReflectionType * type)
{
  int iftmp.42;
  struct MonoVTable * D.27556;
  struct MonoClass * D.27557;
  struct MonoImage * D.27558;
  struct MonoImage * D.27559;
  struct MonoType * D.27561;
  _Bool D.27562;
  long int D.27563;
  long int D.27564;
  unsigned char D.27567;
  _Bool D.27568;
  long int D.27569;
  long int D.27570;
  GenericParameterAttributes D.27573;
  struct MonoGenericParamInfo * iftmp.43;
  struct MonoGenericParam * D.27575;
  struct MonoGenericContainer * D.27576;
  short unsigned int D.27580;

  if (type != 0B) goto <D.27555>; else goto <D.27552>;
  <D.27555>:
  D.27556 = MEM[(struct MonoObject *)type].vtable;
  D.27557 = D.27556->klass;
  D.27558 = D.27557->image;
  D.27559 = mono_defaults.corlib;
  if (D.27558 != D.27559) goto <D.27553>; else goto <D.27560>;
  <D.27560>:
  D.27561 = type->type;
  if (D.27561 == 0B) goto <D.27553>; else goto <D.27552>;
  <D.27553>:
  iftmp.42 = 1;
  goto <D.27554>;
  <D.27552>:
  iftmp.42 = 0;
  <D.27554>:
  D.27562 = iftmp.42 != 0;
  D.27563 = (long int) D.27562;
  D.27564 = __builtin_expect (D.27563, 0);
  if (D.27564 != 0) goto <D.27565>; else goto <D.27566>;
  <D.27565>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "icall.c", 2477, "IS_MONOTYPE (type)");
  <D.27566>:
  D.27561 = type->type;
  D.27567 = is_generic_parameter (D.27561);
  D.27568 = D.27567 == 0;
  D.27569 = (long int) D.27568;
  D.27570 = __builtin_expect (D.27569, 0);
  if (D.27570 != 0) goto <D.27571>; else goto <D.27572>;
  <D.27571>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "icall.c", 2478, "is_generic_parameter (type->type)");
  <D.27572>:
  D.27561 = type->type;
  D.27575 = D.27561->data.generic_param;
  D.27576 = D.27575->owner;
  if (D.27576 != 0B) goto <D.27577>; else goto <D.27578>;
  <D.27577>:
  D.27561 = type->type;
  D.27575 = D.27561->data.generic_param;
  iftmp.43 = &MEM[(struct MonoGenericParamFull *)D.27575].info;
  goto <D.27579>;
  <D.27578>:
  iftmp.43 = 0B;
  <D.27579>:
  D.27580 = iftmp.43->flags;
  D.27573 = (GenericParameterAttributes) D.27580;
  return D.27573;
}


ves_icall_System_Type_EqualsInternal (struct MonoReflectionType * type, struct MonoReflectionType * c)
{
  struct MonoType * D.27584;
  struct MonoType * D.27586;
  MonoBoolean D.27588;
  int D.27589;
  _Bool D.27590;

  if (c != 0B) goto <D.27583>; else goto <D.27582>;
  <D.27583>:
  D.27584 = type->type;
  if (D.27584 != 0B) goto <D.27585>; else goto <D.27582>;
  <D.27585>:
  D.27586 = c->type;
  if (D.27586 != 0B) goto <D.27587>; else goto <D.27582>;
  <D.27587>:
  D.27584 = type->type;
  D.27586 = c->type;
  D.27589 = mono_metadata_type_equal (D.27584, D.27586);
  D.27588 = (MonoBoolean) D.27589;
  return D.27588;
  <D.27582>:
  D.27590 = type == c;
  D.27588 = (MonoBoolean) D.27590;
  return D.27588;
}


ves_icall_System_Text_Encoding_InternalCodePage (gint32 * int_code_page)
{
  const char * cset.44;
  char D.27593;
  int D.27594;
  int D.27595;
  const short unsigned int * * D.27598;
  const short unsigned int * D.27599;
  long unsigned int D.27600;
  long unsigned int D.27601;
  const short unsigned int * D.27602;
  short unsigned int D.27603;
  int D.27604;
  int D.27605;
  int D.23837;
  int D.27610;
  const int iftmp.45;
  unsigned int __c.46;
  unsigned int D.27615;
  const __int32_t * * D.27618;
  const __int32_t * D.27619;
  long unsigned int D.27620;
  long unsigned int D.27621;
  const __int32_t * D.27622;
  long unsigned int D.27626;
  const __int32_t * D.27627;
  char D.27628;
  long int p.47;
  int D.23850;
  char * D.27636;
  int D.27639;
  int D.27640;
  struct MonoString * D.27644;
  struct MonoDomain * D.27645;
  const char * cset;
  const char * p;
  char * c;
  char * codepage;
  int code;
  int want_name;
  int i;

  try
    {
      codepage = 0B;
      want_name = *int_code_page;
      *int_code_page = -1;
      monoeg_g_get_charset (&cset);
      cset.44 = cset;
      codepage = __strdup (cset.44);
      c = codepage;
      c = codepage;
      goto <D.23839>;
      <D.23838>:
      D.27593 = *c;
      D.27594 = (int) D.27593;
      D.27595 = D.27594 & -128;
      if (D.27595 == 0) goto <D.27596>; else goto <D.27597>;
      <D.27596>:
      D.27598 = __ctype_b_loc ();
      D.27599 = *D.27598;
      D.27593 = *c;
      D.27600 = (long unsigned int) D.27593;
      D.27601 = D.27600 * 2;
      D.27602 = D.27599 + D.27601;
      D.27603 = *D.27602;
      D.27604 = (int) D.27603;
      D.27605 = D.27604 & 1024;
      if (D.27605 != 0) goto <D.27606>; else goto <D.27607>;
      <D.27606>:
      {
        int __res;

        {
          if (0 != 0) goto <D.27608>; else goto <D.27609>;
          <D.27608>:
          D.27593 = *c;
          D.27594 = (int) D.27593;
          D.27610 = __builtin_constant_p (D.27594);
          if (D.27610 != 0) goto <D.27611>; else goto <D.27612>;
          <D.27611>:
          {
            int __c;

            D.27593 = *c;
            __c = (int) D.27593;
            __c.46 = (unsigned int) __c;
            D.27615 = __c.46 + 128;
            if (D.27615 <= 383) goto <D.27616>; else goto <D.27617>;
            <D.27616>:
            D.27618 = __ctype_tolower_loc ();
            D.27619 = *D.27618;
            D.27620 = (long unsigned int) __c;
            D.27621 = D.27620 * 4;
            D.27622 = D.27619 + D.27621;
            iftmp.45 = *D.27622;
            goto <D.27623>;
            <D.27617>:
            iftmp.45 = __c;
            <D.27623>:
            __res = iftmp.45;
          }
          goto <D.27624>;
          <D.27612>:
          D.27593 = *c;
          D.27594 = (int) D.27593;
          __res = tolower (D.27594);
          <D.27624>:
          goto <D.27625>;
          <D.27609>:
          D.27618 = __ctype_tolower_loc ();
          D.27619 = *D.27618;
          D.27593 = *c;
          D.27600 = (long unsigned int) D.27593;
          D.27626 = D.27600 * 4;
          D.27627 = D.27619 + D.27626;
          __res = *D.27627;
          <D.27625>:
        }
        D.23837 = __res;
      }
      D.27628 = (char) D.23837;
      *c = D.27628;
      <D.27607>:
      <D.27597>:
      D.27593 = *c;
      if (D.27593 == 45) goto <D.27629>; else goto <D.27630>;
      <D.27629>:
      *c = 95;
      <D.27630>:
      c = c + 1;
      <D.23839>:
      D.27593 = *c;
      if (D.27593 != 0) goto <D.23838>; else goto <D.23840>;
      <D.23840>:
      p = encodings[0];
      code = 0;
      i = 0;
      goto <D.23841>;
      <D.23852>:
      p.47 = (long int) p;
      if (p.47 <= 6) goto <D.27632>; else goto <D.27633>;
      <D.27632>:
      p.47 = (long int) p;
      code = (int) p.47;
      i = i + 1;
      p = encodings[i];
      // predicted unlikely by continue predictor.
      goto <D.23841>;
      <D.27633>:
      {
        size_t __s1_len;
        size_t __s2_len;

        D.23850 = __builtin_strcmp (p, codepage);
      }
      if (D.23850 == 0) goto <D.27634>; else goto <D.27635>;
      <D.27634>:
      *int_code_page = code;
      goto <D.23851>;
      <D.27635>:
      i = i + 1;
      p = encodings[i];
      <D.23841>:
      if (p != 0B) goto <D.23852>; else goto <D.23851>;
      <D.23851>:
      D.27636 = strstr (codepage, "utf_8");
      if (D.27636 != 0B) goto <D.27637>; else goto <D.27638>;
      <D.27637>:
      D.27639 = *int_code_page;
      D.27640 = D.27639 | 268435456;
      *int_code_page = D.27640;
      <D.27638>:
      free (codepage);
      if (want_name != 0) goto <D.27642>; else goto <D.27641>;
      <D.27642>:
      D.27639 = *int_code_page;
      if (D.27639 == -1) goto <D.27643>; else goto <D.27641>;
      <D.27643>:
      D.27645 = mono_domain_get ();
      cset.44 = cset;
      D.27644 = mono_string_new (D.27645, cset.44);
      return D.27644;
      <D.27641>:
      D.27644 = 0B;
      return D.27644;
    }
  finally
    {
      cset = {CLOBBER};
    }
}


ves_icall_RuntimeMethod_GetFunctionPointer (struct MonoMethod * method)
{
  void * D.27648;

  D.27648 = mono_compile_method (method);
  return D.27648;
}


ves_icall_IsTransparentProxy (struct MonoObject * proxy)
{
  MonoBoolean D.27652;
  struct MonoVTable * D.27653;
  struct MonoClass * D.27654;
  struct MonoClass * D.27655;

  if (proxy == 0B) goto <D.27650>; else goto <D.27651>;
  <D.27650>:
  D.27652 = 0;
  return D.27652;
  <D.27651>:
  D.27653 = proxy->vtable;
  D.27654 = D.27653->klass;
  D.27655 = mono_defaults.transparent_proxy_class;
  if (D.27654 == D.27655) goto <D.27656>; else goto <D.27657>;
  <D.27656>:
  D.27652 = 1;
  return D.27652;
  <D.27657>:
  D.27652 = 0;
  return D.27652;
}


ves_icall_InternalExecute (struct MonoReflectionMethod * method, struct MonoObject * this, struct MonoArray * params, struct MonoArray * * outArgs)
{
  struct MonoVTable * D.27659;
  struct MonoClass * D.27660;
  struct MonoClass * D.27661;
  int D.22437;
  int iftmp.48;
  int D.22436;
  const char[12] * D.27667;
  unsigned char D.27668;
  int D.27669;
  unsigned char D.27670;
  int D.27671;
  const unsigned char * D.27676;
  unsigned char D.27677;
  int D.27678;
  const unsigned char * D.27679;
  unsigned char D.27680;
  int D.27681;
  const unsigned char * D.27686;
  unsigned char D.27687;
  int D.27688;
  const unsigned char * D.27689;
  unsigned char D.27690;
  int D.27691;
  const unsigned char * D.27696;
  unsigned char D.27697;
  int D.27698;
  const unsigned char * D.27699;
  unsigned char D.27700;
  int D.27701;
  const char * D.27703;
  struct MonoVTable * D.27706;
  struct MonoClass * D.27707;
  struct MonoRealProxy * D.27710;
  _Bool D.27711;
  long int D.27712;
  long int D.27713;
  char * D.27716;
  struct MonoType * D.27719;
  long unsigned int D.27720;
  long unsigned int D.27721;
  int D.27724;
  sizetype D.27725;
  void * D.27726;
  void * * D.27728;
  struct MonoObject * D.27729;
  int D.22455;
  int iftmp.49;
  int D.22454;
  const char[12] * D.27733;
  unsigned char D.27734;
  int D.27735;
  unsigned char D.27736;
  int D.27737;
  const unsigned char * D.27742;
  unsigned char D.27743;
  int D.27744;
  const unsigned char * D.27745;
  unsigned char D.27746;
  int D.27747;
  const unsigned char * D.27752;
  unsigned char D.27753;
  int D.27754;
  const unsigned char * D.27755;
  unsigned char D.27756;
  int D.27757;
  const unsigned char * D.27762;
  unsigned char D.27763;
  int D.27764;
  const unsigned char * D.27765;
  unsigned char D.27766;
  int D.27767;
  struct MonoRealProxy * D.27773;
  char * D.27776;
  struct MonoType * D.27779;
  char * D.27780;
  long unsigned int D.27781;
  long unsigned int D.27782;
  int D.27785;
  int D.27786;
  unsigned int D.27787;
  _Bool D.27788;
  long int D.27789;
  long int D.27790;
  int D.27793;
  sizetype D.27794;
  void * D.27795;
  void * D.27796;
  struct MonoType * D.27798;
  long unsigned int D.27799;
  long unsigned int D.27800;
  long unsigned int D.27803;
  long unsigned int D.27804;
  long unsigned int D.27805;
  int D.22478;
  int iftmp.50;
  int D.22477;
  struct MonoMethod * D.27809;
  const char[6] * D.27810;
  unsigned char D.27811;
  int D.27812;
  unsigned char D.27813;
  int D.27814;
  const unsigned char * D.27819;
  unsigned char D.27820;
  int D.27821;
  const unsigned char * D.27822;
  unsigned char D.27823;
  int D.27824;
  const unsigned char * D.27829;
  unsigned char D.27830;
  int D.27831;
  const unsigned char * D.27832;
  unsigned char D.27833;
  int D.27834;
  const unsigned char * D.27839;
  unsigned char D.27840;
  int D.27841;
  const unsigned char * D.27842;
  unsigned char D.27843;
  int D.27844;
  const char * D.27846;
  struct MonoClass * D.27851;
  long unsigned int D.27852;
  long unsigned int D.27853;
  _Bool D.27854;
  long int D.27855;
  long int D.27856;
  char * D.27861;
  long unsigned int D.27862;
  long unsigned int D.27863;
  struct MonoDomain * domain;
  struct MonoMethod * m;
  struct MonoMethodSignature * sig;
  struct MonoArray * out_args;
  struct MonoObject * result;
  int i;
  int j;
  int outarg_count;

  D.27659 = MEM[(struct MonoObject *)method].vtable;
  domain = D.27659->domain;
  m = method->method;
  sig = mono_method_signature (m);
  outarg_count = 0;
  D.27660 = m->klass;
  D.27661 = mono_defaults.object_class;
  if (D.27660 == D.27661) goto <D.27662>; else goto <D.27663>;
  <D.27662>:
  {
    size_t __s1_len;
    size_t __s2_len;

    __s2_len = 11;
    if (__s2_len <= 3) goto <D.27665>; else goto <D.27666>;
    <D.27665>:
    {
      const unsigned char * __s2;
      int __result;

      __s2 = m->name;
      D.27667 = "FieldGetter";
      D.27668 = MEM[(const unsigned char *)D.27667];
      D.27669 = (int) D.27668;
      D.27670 = *__s2;
      D.27671 = (int) D.27670;
      __result = D.27669 - D.27671;
      {
        if (__s2_len != 0) goto <D.27672>; else goto <D.27673>;
        <D.27672>:
        if (__result == 0) goto <D.27674>; else goto <D.27675>;
        <D.27674>:
        D.27676 = &MEM[(void *)"FieldGetter" + 1B];
        D.27677 = *D.27676;
        D.27678 = (int) D.27677;
        D.27679 = __s2 + 1;
        D.27680 = *D.27679;
        D.27681 = (int) D.27680;
        __result = D.27678 - D.27681;
        if (__s2_len > 1) goto <D.27682>; else goto <D.27683>;
        <D.27682>:
        if (__result == 0) goto <D.27684>; else goto <D.27685>;
        <D.27684>:
        D.27686 = &MEM[(void *)"FieldGetter" + 2B];
        D.27687 = *D.27686;
        D.27688 = (int) D.27687;
        D.27689 = __s2 + 2;
        D.27690 = *D.27689;
        D.27691 = (int) D.27690;
        __result = D.27688 - D.27691;
        if (__s2_len > 2) goto <D.27692>; else goto <D.27693>;
        <D.27692>:
        if (__result == 0) goto <D.27694>; else goto <D.27695>;
        <D.27694>:
        D.27696 = &MEM[(void *)"FieldGetter" + 3B];
        D.27697 = *D.27696;
        D.27698 = (int) D.27697;
        D.27699 = __s2 + 3;
        D.27700 = *D.27699;
        D.27701 = (int) D.27700;
        __result = D.27698 - D.27701;
        <D.27695>:
        <D.27693>:
        <D.27685>:
        <D.27683>:
        <D.27675>:
        <D.27673>:
      }
      D.22436 = __result;
    }
    iftmp.48 = -D.22436;
    goto <D.27702>;
    <D.27666>:
    D.27703 = m->name;
    iftmp.48 = __builtin_strcmp (D.27703, "FieldGetter");
    <D.27702>:
    D.22437 = iftmp.48;
  }
  if (D.22437 == 0) goto <D.27704>; else goto <D.27705>;
  <D.27704>:
  {
    struct MonoClass * k;
    struct MonoString * name;
    char * str;

    D.27706 = this->vtable;
    k = D.27706->klass;
    D.27707 = mono_defaults.transparent_proxy_class;
    if (D.27707 == k) goto <D.27708>; else goto <D.27709>;
    <D.27708>:
    {
      struct MonoTransparentProxy * tp;

      tp = this;
      D.27710 = tp->rp;
      this = D.27710->unwrapped_server;
      D.27711 = this == 0B;
      D.27712 = (long int) D.27711;
      D.27713 = __builtin_expect (D.27712, 0);
      if (D.27713 != 0) goto <D.27714>; else goto <D.27715>;
      <D.27714>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "icall.c", 2870, "this");
      <D.27715>:
      D.27706 = this->vtable;
      k = D.27706->klass;
    }
    <D.27709>:
    D.27716 = mono_array_addr_with_size (params, 8, 1);
    name = MEM[(struct MonoString * *)D.27716];
    str = mono_string_to_utf8 (name);
    <D.22445>:
    {
      struct MonoClassField * field;

      field = mono_class_get_field_from_name (k, str);
      if (field != 0B) goto <D.27717>; else goto <D.27718>;
      <D.27717>:
      {
        struct MonoClass * field_klass;

        D.27719 = field->type;
        field_klass = mono_class_from_mono_type (D.27719);
        D.27720 = BIT_FIELD_REF <*field_klass, 64, 256>;
        D.27721 = D.27720 & 8;
        if (D.27721 != 0) goto <D.27722>; else goto <D.27723>;
        <D.27722>:
        D.27724 = field->offset;
        D.27725 = (sizetype) D.27724;
        D.27726 = this + D.27725;
        result = mono_value_box (domain, field_klass, D.27726);
        goto <D.27727>;
        <D.27723>:
        D.27724 = field->offset;
        D.27725 = (sizetype) D.27724;
        D.27728 = this + D.27725;
        result = *D.27728;
        <D.27727>:
        D.27661 = mono_defaults.object_class;
        out_args = mono_array_new (domain, D.27661, 1);
        mono_gc_wbarrier_generic_store (outArgs, out_args);
        {
          void * * __p;

          __p = mono_array_addr_with_size (out_args, 8, 0);
          mono_gc_wbarrier_set_arrayref (out_args, __p, result);
        }
        monoeg_g_free (str);
        D.27729 = 0B;
        return D.27729;
      }
      <D.27718>:
      k = k->parent;
    }
    if (k != 0B) goto <D.22445>; else goto <D.22446>;
    <D.22446>:
    monoeg_g_free (str);
    monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "icall.c", 2896);
  }
  <D.27705>:
  {
    size_t __s1_len;
    size_t __s2_len;

    __s2_len = 11;
    if (__s2_len <= 3) goto <D.27731>; else goto <D.27732>;
    <D.27731>:
    {
      const unsigned char * __s2;
      int __result;

      __s2 = m->name;
      D.27733 = "FieldSetter";
      D.27734 = MEM[(const unsigned char *)D.27733];
      D.27735 = (int) D.27734;
      D.27736 = *__s2;
      D.27737 = (int) D.27736;
      __result = D.27735 - D.27737;
      {
        if (__s2_len != 0) goto <D.27738>; else goto <D.27739>;
        <D.27738>:
        if (__result == 0) goto <D.27740>; else goto <D.27741>;
        <D.27740>:
        D.27742 = &MEM[(void *)"FieldSetter" + 1B];
        D.27743 = *D.27742;
        D.27744 = (int) D.27743;
        D.27745 = __s2 + 1;
        D.27746 = *D.27745;
        D.27747 = (int) D.27746;
        __result = D.27744 - D.27747;
        if (__s2_len > 1) goto <D.27748>; else goto <D.27749>;
        <D.27748>:
        if (__result == 0) goto <D.27750>; else goto <D.27751>;
        <D.27750>:
        D.27752 = &MEM[(void *)"FieldSetter" + 2B];
        D.27753 = *D.27752;
        D.27754 = (int) D.27753;
        D.27755 = __s2 + 2;
        D.27756 = *D.27755;
        D.27757 = (int) D.27756;
        __result = D.27754 - D.27757;
        if (__s2_len > 2) goto <D.27758>; else goto <D.27759>;
        <D.27758>:
        if (__result == 0) goto <D.27760>; else goto <D.27761>;
        <D.27760>:
        D.27762 = &MEM[(void *)"FieldSetter" + 3B];
        D.27763 = *D.27762;
        D.27764 = (int) D.27763;
        D.27765 = __s2 + 3;
        D.27766 = *D.27765;
        D.27767 = (int) D.27766;
        __result = D.27764 - D.27767;
        <D.27761>:
        <D.27759>:
        <D.27751>:
        <D.27749>:
        <D.27741>:
        <D.27739>:
      }
      D.22454 = __result;
    }
    iftmp.49 = -D.22454;
    goto <D.27768>;
    <D.27732>:
    D.27703 = m->name;
    iftmp.49 = __builtin_strcmp (D.27703, "FieldSetter");
    <D.27768>:
    D.22455 = iftmp.49;
  }
  if (D.22455 == 0) goto <D.27769>; else goto <D.27770>;
  <D.27769>:
  {
    struct MonoClass * k;
    struct MonoString * name;
    guint32 size;
    gint32 align;
    char * str;

    try
      {
        D.27706 = this->vtable;
        k = D.27706->klass;
        D.27707 = mono_defaults.transparent_proxy_class;
        if (D.27707 == k) goto <D.27771>; else goto <D.27772>;
        <D.27771>:
        {
          struct MonoTransparentProxy * tp;

          tp = this;
          D.27773 = tp->rp;
          this = D.27773->unwrapped_server;
          D.27711 = this == 0B;
          D.27712 = (long int) D.27711;
          D.27713 = __builtin_expect (D.27712, 0);
          if (D.27713 != 0) goto <D.27774>; else goto <D.27775>;
          <D.27774>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "icall.c", 2909, "this");
          <D.27775>:
          D.27706 = this->vtable;
          k = D.27706->klass;
        }
        <D.27772>:
        D.27776 = mono_array_addr_with_size (params, 8, 1);
        name = MEM[(struct MonoString * *)D.27776];
        str = mono_string_to_utf8 (name);
        <D.22465>:
        {
          struct MonoClassField * field;

          field = mono_class_get_field_from_name (k, str);
          if (field != 0B) goto <D.27777>; else goto <D.27778>;
          <D.27777>:
          {
            struct MonoClass * field_klass;
            struct MonoObject * val;

            D.27779 = field->type;
            field_klass = mono_class_from_mono_type (D.27779);
            D.27780 = mono_array_addr_with_size (params, 8, 2);
            val = MEM[(void * *)D.27780];
            D.27781 = BIT_FIELD_REF <*field_klass, 64, 256>;
            D.27782 = D.27781 & 8;
            if (D.27782 != 0) goto <D.27783>; else goto <D.27784>;
            <D.27783>:
            D.27779 = field->type;
            D.27785 = mono_type_size (D.27779, &align);
            size = (guint32) D.27785;
            D.27786 = mono_class_value_size (field_klass, 0B);
            D.27787 = (unsigned int) D.27786;
            D.27788 = D.27787 != size;
            D.27789 = (long int) D.27788;
            D.27790 = __builtin_expect (D.27789, 0);
            if (D.27790 != 0) goto <D.27791>; else goto <D.27792>;
            <D.27791>:
            monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "icall.c", 2924, "size == mono_class_value_size (field_klass, NULL)");
            <D.27792>:
            D.27793 = field->offset;
            D.27794 = (sizetype) D.27793;
            D.27795 = this + D.27794;
            D.27796 = val + 16;
            mono_gc_wbarrier_value_copy (D.27795, D.27796, 1, field_klass);
            goto <D.27797>;
            <D.27784>:
            D.27793 = field->offset;
            D.27794 = (sizetype) D.27793;
            D.27795 = this + D.27794;
            mono_gc_wbarrier_set_field (this, D.27795, val);
            <D.27797>:
            D.27661 = mono_defaults.object_class;
            out_args = mono_array_new (domain, D.27661, 0);
            mono_gc_wbarrier_generic_store (outArgs, out_args);
            monoeg_g_free (str);
            D.27729 = 0B;
            return D.27729;
          }
          <D.27778>:
          k = k->parent;
        }
        if (k != 0B) goto <D.22465>; else goto <D.22466>;
        <D.22466>:
        monoeg_g_free (str);
        monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "icall.c", 2941);
      }
    finally
      {
        align = {CLOBBER};
      }
  }
  <D.27770>:
  <D.27663>:
  i = 0;
  goto <D.22468>;
  <D.22467>:
  D.27798 = sig->params[i];
  D.27799 = BIT_FIELD_REF <*D.27798, 64, 64>;
  D.27800 = D.27799 & 1073741824;
  if (D.27800 != 0) goto <D.27801>; else goto <D.27802>;
  <D.27801>:
  outarg_count = outarg_count + 1;
  <D.27802>:
  i = i + 1;
  <D.22468>:
  D.27803 = (long unsigned int) i;
  D.27804 = mono_array_length (params);
  if (D.27803 < D.27804) goto <D.22467>; else goto <D.22469>;
  <D.22469>:
  D.27661 = mono_defaults.object_class;
  D.27805 = (long unsigned int) outarg_count;
  out_args = mono_array_new (domain, D.27661, D.27805);
  {
    size_t __s1_len;
    size_t __s2_len;

    __s2_len = 5;
    if (__s2_len <= 3) goto <D.27807>; else goto <D.27808>;
    <D.27807>:
    {
      const unsigned char * __s2;
      int __result;

      D.27809 = method->method;
      __s2 = D.27809->name;
      D.27810 = ".ctor";
      D.27811 = MEM[(const unsigned char *)D.27810];
      D.27812 = (int) D.27811;
      D.27813 = *__s2;
      D.27814 = (int) D.27813;
      __result = D.27812 - D.27814;
      {
        if (__s2_len != 0) goto <D.27815>; else goto <D.27816>;
        <D.27815>:
        if (__result == 0) goto <D.27817>; else goto <D.27818>;
        <D.27817>:
        D.27819 = &MEM[(void *)".ctor" + 1B];
        D.27820 = *D.27819;
        D.27821 = (int) D.27820;
        D.27822 = __s2 + 1;
        D.27823 = *D.27822;
        D.27824 = (int) D.27823;
        __result = D.27821 - D.27824;
        if (__s2_len > 1) goto <D.27825>; else goto <D.27826>;
        <D.27825>:
        if (__result == 0) goto <D.27827>; else goto <D.27828>;
        <D.27827>:
        D.27829 = &MEM[(void *)".ctor" + 2B];
        D.27830 = *D.27829;
        D.27831 = (int) D.27830;
        D.27832 = __s2 + 2;
        D.27833 = *D.27832;
        D.27834 = (int) D.27833;
        __result = D.27831 - D.27834;
        if (__s2_len > 2) goto <D.27835>; else goto <D.27836>;
        <D.27835>:
        if (__result == 0) goto <D.27837>; else goto <D.27838>;
        <D.27837>:
        D.27839 = &MEM[(void *)".ctor" + 3B];
        D.27840 = *D.27839;
        D.27841 = (int) D.27840;
        D.27842 = __s2 + 3;
        D.27843 = *D.27842;
        D.27844 = (int) D.27843;
        __result = D.27841 - D.27844;
        <D.27838>:
        <D.27836>:
        <D.27828>:
        <D.27826>:
        <D.27818>:
        <D.27816>:
      }
      D.22477 = __result;
    }
    iftmp.50 = -D.22477;
    goto <D.27845>;
    <D.27808>:
    D.27809 = method->method;
    D.27846 = D.27809->name;
    iftmp.50 = __builtin_strcmp (D.27846, ".ctor");
    <D.27845>:
    D.22478 = iftmp.50;
  }
  if (D.22478 == 0) goto <D.27847>; else goto <D.27848>;
  <D.27847>:
  D.27711 = this == 0B;
  D.27712 = (long int) D.27711;
  D.27713 = __builtin_expect (D.27712, 0);
  if (D.27713 != 0) goto <D.27849>; else goto <D.27850>;
  <D.27849>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "icall.c", 2955, "this");
  <D.27850>:
  <D.27848>:
  D.27809 = method->method;
  D.27851 = D.27809->klass;
  D.27852 = BIT_FIELD_REF <*D.27851, 64, 256>;
  D.27853 = D.27852 & 8;
  D.27854 = D.27853 != 0;
  D.27855 = (long int) D.27854;
  D.27856 = __builtin_expect (D.27855, 0);
  if (D.27856 != 0) goto <D.27857>; else goto <D.27858>;
  <D.27857>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "icall.c", 2958, "!method->method->klass->valuetype");
  <D.27858>:
  D.27809 = method->method;
  result = mono_runtime_invoke_array (D.27809, this, params, 0B);
  i = 0;
  j = 0;
  goto <D.22482>;
  <D.22481>:
  D.27798 = sig->params[i];
  D.27799 = BIT_FIELD_REF <*D.27798, 64, 64>;
  D.27800 = D.27799 & 1073741824;
  if (D.27800 != 0) goto <D.27859>; else goto <D.27860>;
  <D.27859>:
  {
    void * arg;

    D.27803 = (long unsigned int) i;
    D.27861 = mono_array_addr_with_size (params, 8, D.27803);
    arg = MEM[(void * *)D.27861];
    {
      void * * __p;

      D.27862 = (long unsigned int) j;
      __p = mono_array_addr_with_size (out_args, 8, D.27862);
      mono_gc_wbarrier_set_arrayref (out_args, __p, arg);
    }
    j = j + 1;
  }
  <D.27860>:
  i = i + 1;
  <D.22482>:
  D.27803 = (long unsigned int) i;
  D.27863 = mono_array_length (params);
  if (D.27803 < D.27863) goto <D.22481>; else goto <D.22483>;
  <D.22483>:
  mono_gc_wbarrier_generic_store (outArgs, out_args);
  D.27729 = result;
  return D.27729;
}


ves_icall_Remoting_RemotingServices_GetVirtualMethod (struct MonoReflectionType * rtype, struct MonoReflectionMethod * rmethod)
{
  _Bool D.27866;
  long int D.27867;
  long int D.27868;
  _Bool D.27873;
  long int D.27874;
  long int D.27875;
  struct MonoType * D.27880;
  unsigned int D.27883;
  unsigned int D.27884;
  unsigned char D.27886;
  struct MonoReflectionMethod * D.27888;
  short unsigned int D.27889;
  int D.27890;
  int D.27891;
  unsigned int D.27894;
  unsigned int D.27895;
  struct MonoClass * D.27900;
  int D.27902;
  unsigned int D.27903;
  unsigned int D.27904;
  short int D.27909;
  int D.27910;
  int D.27911;
  long unsigned int D.27912;
  long unsigned int D.27913;
  struct MonoMethod * * D.27914;
  int D.27918;
  long unsigned int D.27923;
  long unsigned int D.27924;
  struct MonoMethod * * D.27925;
  struct MonoDomain * D.27928;
  struct MonoClass * klass;
  struct MonoMethod * method;
  struct MonoMethod * * vtable;
  struct MonoMethod * res;

  res = 0B;
  D.27866 = rtype == 0B;
  D.27867 = (long int) D.27866;
  D.27868 = __builtin_expect (D.27867, 0);
  if (D.27868 != 0) goto <D.27869>; else goto <D.27870>;
  <D.27869>:
  {
    struct MonoException * ex;

    if (rtype != 0B) goto <D.27871>; else goto <D.27872>;
    <D.27871>:
    <D.27872>:
    ex = mono_get_exception_argument_null ("rtype");
    mono_raise_exception (ex);
  }
  <D.27870>:
  D.27873 = rmethod == 0B;
  D.27874 = (long int) D.27873;
  D.27875 = __builtin_expect (D.27874, 0);
  if (D.27875 != 0) goto <D.27876>; else goto <D.27877>;
  <D.27876>:
  {
    struct MonoException * ex;

    if (rmethod != 0B) goto <D.27878>; else goto <D.27879>;
    <D.27878>:
    <D.27879>:
    ex = mono_get_exception_argument_null ("rmethod");
    mono_raise_exception (ex);
  }
  <D.27877>:
  method = rmethod->method;
  D.27880 = rtype->type;
  klass = mono_class_from_mono_type (D.27880);
  mono_class_init_or_throw (klass);
  D.27883 = klass->flags;
  D.27884 = D.27883 & 32;
  if (D.27884 != 0) goto <D.27881>; else goto <D.27885>;
  <D.27885>:
  D.27886 = klass->byval_arg.type;
  if (D.27886 == 19) goto <D.27881>; else goto <D.27887>;
  <D.27887>:
  D.27886 = klass->byval_arg.type;
  if (D.27886 == 30) goto <D.27881>; else goto <D.27882>;
  <D.27881>:
  D.27888 = 0B;
  return D.27888;
  <D.27882>:
  D.27889 = method->flags;
  D.27890 = (int) D.27889;
  D.27891 = D.27890 & 16;
  if (D.27891 != 0) goto <D.27892>; else goto <D.27893>;
  <D.27892>:
  D.27888 = 0B;
  return D.27888;
  <D.27893>:
  D.27889 = method->flags;
  D.27894 = (unsigned int) D.27889;
  D.27895 = D.27894 & 96;
  if (D.27895 != 64) goto <D.27896>; else goto <D.27897>;
  <D.27896>:
  D.27900 = method->klass;
  if (D.27900 == klass) goto <D.27898>; else goto <D.27901>;
  <D.27901>:
  D.27900 = method->klass;
  D.27902 = mono_class_is_subclass_of (klass, D.27900, 0);
  if (D.27902 != 0) goto <D.27898>; else goto <D.27899>;
  <D.27898>:
  D.27888 = rmethod;
  return D.27888;
  <D.27899>:
  D.27888 = 0B;
  return D.27888;
  <D.27897>:
  mono_class_setup_vtable (klass);
  vtable = klass->vtable;
  D.27900 = method->klass;
  D.27903 = D.27900->flags;
  D.27904 = D.27903 & 32;
  if (D.27904 != 0) goto <D.27905>; else goto <D.27906>;
  <D.27905>:
  {
    gboolean variance_used;
    int offs;

    try
      {
        variance_used = 0;
        D.27900 = method->klass;
        offs = mono_class_interface_offset_with_variance (klass, D.27900, &variance_used);
        if (offs >= 0) goto <D.27907>; else goto <D.27908>;
        <D.27907>:
        D.27909 = method->slot;
        D.27910 = (int) D.27909;
        D.27911 = D.27910 + offs;
        D.27912 = (long unsigned int) D.27911;
        D.27913 = D.27912 * 8;
        D.27914 = vtable + D.27913;
        res = *D.27914;
        <D.27908>:
      }
    finally
      {
        variance_used = {CLOBBER};
      }
  }
  goto <D.27915>;
  <D.27906>:
  D.27900 = method->klass;
  if (D.27900 != klass) goto <D.27916>; else goto <D.27917>;
  <D.27916>:
  D.27900 = method->klass;
  D.27918 = mono_class_is_subclass_of (klass, D.27900, 0);
  if (D.27918 == 0) goto <D.27919>; else goto <D.27920>;
  <D.27919>:
  D.27888 = 0B;
  return D.27888;
  <D.27920>:
  <D.27917>:
  D.27909 = method->slot;
  if (D.27909 != -1) goto <D.27921>; else goto <D.27922>;
  <D.27921>:
  D.27909 = method->slot;
  D.27923 = (long unsigned int) D.27909;
  D.27924 = D.27923 * 8;
  D.27925 = vtable + D.27924;
  res = *D.27925;
  <D.27922>:
  <D.27915>:
  if (res == 0B) goto <D.27926>; else goto <D.27927>;
  <D.27926>:
  D.27888 = 0B;
  return D.27888;
  <D.27927>:
  D.27928 = mono_domain_get ();
  D.27888 = mono_method_get_object (D.27928, res, 0B);
  return D.27888;
}


ves_icall_Remoting_RealProxy_GetTransparentProxy (struct MonoObject * this, struct MonoString * class_name)
{
  struct MonoVTable * D.27930;
  struct MonoClass * D.27931;
  struct MonoRealProxy * * D.27932;
  struct MonoReflectionType * D.27933;
  struct MonoClass * D.27934;
  struct MonoObject * D.27935;
  _Bool D.27936;
  unsigned char D.27937;
  struct MonoRemoteClass * D.27938;
  struct MonoRemoteClass * D.27939;
  void * D.27940;
  struct MonoObject * D.27941;
  struct MonoDomain * domain;
  struct MonoObject * res;
  struct MonoRealProxy * rp;
  struct MonoTransparentProxy * tp;
  struct MonoType * type;
  struct MonoClass * klass;

  D.27930 = this->vtable;
  domain = D.27930->domain;
  rp = this;
  D.27931 = mono_defaults.transparent_proxy_class;
  res = mono_object_new (domain, D.27931);
  tp = res;
  D.27932 = &tp->rp;
  mono_gc_wbarrier_set_field (tp, D.27932, rp);
  D.27933 = rp->class_to_proxy;
  type = D.27933->type;
  klass = mono_class_from_mono_type (type);
  D.27934 = mono_defaults.iremotingtypeinfo_class;
  D.27935 = mono_object_isinst (this, D.27934);
  D.27936 = D.27935 != 0B;
  D.27937 = (unsigned char) D.27936;
  tp->custom_type_info = D.27937;
  D.27938 = mono_remote_class (domain, class_name, klass);
  tp->remote_class = D.27938;
  D.27939 = tp->remote_class;
  D.27940 = mono_remote_class_vtable (domain, D.27939, rp);
  res->vtable = D.27940;
  D.27941 = res;
  return D.27941;
}


ves_icall_Remoting_RealProxy_InternalGetProxyType (struct MonoTransparentProxy * tp)
{
  struct MonoReflectionType * D.27943;
  struct MonoVTable * D.27944;
  struct MonoDomain * D.27945;
  struct MonoRemoteClass * D.27946;
  struct MonoClass * D.27947;
  struct MonoType * D.27948;

  D.27944 = MEM[(struct MonoObject *)tp].vtable;
  D.27945 = D.27944->domain;
  D.27946 = tp->remote_class;
  D.27947 = D.27946->proxy_class;
  D.27948 = &D.27947->byval_arg;
  D.27943 = mono_type_get_object (D.27945, D.27948);
  return D.27943;
}


ves_icall_MonoMethodMessage_InitMessage (struct MonoMethodMessage * this, struct MonoReflectionMethod * method, struct MonoArray * out_args)
{
  struct MonoVTable * D.27950;
  struct MonoDomain * D.27951;

  D.27950 = MEM[(struct MonoObject *)this].vtable;
  D.27951 = D.27950->domain;
  mono_message_init (D.27951, this, method, out_args);
}


ves_icall_System_Runtime_Activation_ActivationServices_EnableProxyActivation (struct MonoReflectionType * type, MonoBoolean enable)
{
  struct MonoType * D.27952;
  struct MonoDomain * D.27953;
  _Bool D.27954;
  struct MonoClass * klass;
  struct MonoVTable * vtable;

  D.27952 = type->type;
  klass = mono_class_from_mono_type (D.27952);
  D.27953 = mono_domain_get ();
  vtable = mono_class_vtable_full (D.27953, klass, 1);
  D.27954 = enable != 0;
  vtable->remote = D.27954;
}


ves_icall_System_Runtime_Activation_ActivationServices_AllocateUninitializedClassInstance (struct MonoReflectionType * type)
{
  struct MonoVTable * D.27955;
  struct MonoType * D.27956;
  unsigned int D.27959;
  unsigned int D.27960;
  unsigned char D.27962;
  unsigned int D.27965;
  struct MonoException * D.27966;
  unsigned char D.27967;
  _Bool D.27970;
  long int D.27971;
  long int D.27972;
  struct MonoObject * D.27975;
  struct MonoClass * D.27976;
  struct MonoVTable * D.27977;
  struct MonoClass * klass;
  struct MonoDomain * domain;

  D.27955 = MEM[(struct MonoObject *)type].vtable;
  domain = D.27955->domain;
  D.27956 = type->type;
  klass = mono_class_from_mono_type (D.27956);
  mono_class_init_or_throw (klass);
  D.27959 = klass->flags;
  D.27960 = D.27959 & 32;
  if (D.27960 != 0) goto <D.27957>; else goto <D.27961>;
  <D.27961>:
  D.27962 = klass->byval_arg.type;
  if (D.27962 == 19) goto <D.27957>; else goto <D.27963>;
  <D.27963>:
  D.27962 = klass->byval_arg.type;
  if (D.27962 == 30) goto <D.27957>; else goto <D.27964>;
  <D.27964>:
  D.27959 = klass->flags;
  D.27965 = D.27959 & 128;
  if (D.27965 != 0) goto <D.27957>; else goto <D.27958>;
  <D.27957>:
  D.27966 = mono_get_exception_argument ("type", "Type cannot be instantiated");
  mono_raise_exception (D.27966);
  <D.27958>:
  D.27967 = klass->rank;
  if (D.27967 != 0) goto <D.27968>; else goto <D.27969>;
  <D.27968>:
  D.27967 = klass->rank;
  D.27970 = D.27967 != 1;
  D.27971 = (long int) D.27970;
  D.27972 = __builtin_expect (D.27971, 0);
  if (D.27972 != 0) goto <D.27973>; else goto <D.27974>;
  <D.27973>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "icall.c", 6838, "klass->rank == 1");
  <D.27974>:
  D.27976 = klass->element_class;
  D.27975 = mono_array_new (domain, D.27976, 0);
  return D.27975;
  <D.27969>:
  D.27977 = mono_class_vtable_full (domain, klass, 1);
  D.27975 = mono_object_new_alloc_specific (D.27977);
  return D.27975;
}


ves_icall_System_Runtime_InteropServices_Marshal_PrelinkAll (struct MonoReflectionType * type)
{
  struct MonoType * D.27979;
  struct MonoClass * klass;
  struct MonoMethod * m;
  void * iter;

  try
    {
      D.27979 = type->type;
      klass = mono_class_from_mono_type (D.27979);
      iter = 0B;
      mono_class_init_or_throw (klass);
      goto <D.24032>;
      <D.24031>:
      prelink_method (m);
      <D.24032>:
      m = mono_class_get_methods (klass, &iter);
      if (m != 0B) goto <D.24031>; else goto <D.24033>;
      <D.24033>:
    }
  finally
    {
      iter = {CLOBBER};
    }
}


prelink_method (struct MonoMethod * method)
{
  short unsigned int D.27980;
  int D.27981;
  int D.27982;
  const char * exc_class.51;
  struct MonoImage * D.27988;
  const char * exc_arg.52;
  struct MonoException * D.27990;
  const char * exc_class;
  const char * exc_arg;

  try
    {
      D.27980 = method->flags;
      D.27981 = (int) D.27980;
      D.27982 = D.27981 & 8192;
      if (D.27982 == 0) goto <D.27983>; else goto <D.27984>;
      <D.27983>:
      return;
      <D.27984>:
      mono_lookup_pinvoke_call (method, &exc_class, &exc_arg);
      exc_class.51 = exc_class;
      if (exc_class.51 != 0B) goto <D.27986>; else goto <D.27987>;
      <D.27986>:
      D.27988 = mono_defaults.corlib;
      exc_class.51 = exc_class;
      exc_arg.52 = exc_arg;
      D.27990 = mono_exception_from_name_msg (D.27988, "System", exc_class.51, exc_arg.52);
      mono_raise_exception (D.27990);
      <D.27987>:
    }
  finally
    {
      exc_class = {CLOBBER};
      exc_arg = {CLOBBER};
    }
}


ves_icall_System_Runtime_InteropServices_Marshal_Prelink (struct MonoReflectionMethod * method)
{
  struct MonoMethod * D.27994;

  D.27994 = method->method;
  prelink_method (D.27994);
}


ves_icall_System_Runtime_CompilerServices_RuntimeHelpers_SufficientExecutionStack ()
{
  guint8 * stack_addr.53;
  MonoBoolean D.27998;
  long int current.54;
  long int stack_addr.55;
  long int D.28003;
  long int D.28004;
  long unsigned int stack_size.56;
  sizetype D.28009;
  guint8 * D.28010;
  long int D.28011;
  long int D.28012;
  guint8 * stack_addr;
  guint8 * current;
  size_t stack_size;
  int min_size;

  try
    {
      min_size = 131072;
      mono_thread_get_stack_bounds (&stack_addr, &stack_size);
      stack_addr.53 = stack_addr;
      if (stack_addr.53 == 0B) goto <D.27996>; else goto <D.27997>;
      <D.27996>:
      D.27998 = 1;
      return D.27998;
      <D.27997>:
      current = &stack_addr;
      stack_addr.53 = stack_addr;
      if (current > stack_addr.53) goto <D.27999>; else goto <D.28000>;
      <D.27999>:
      current.54 = (long int) current;
      stack_addr.53 = stack_addr;
      stack_addr.55 = (long int) stack_addr.53;
      D.28003 = current.54 - stack_addr.55;
      D.28004 = (long int) min_size;
      if (D.28003 < D.28004) goto <D.28005>; else goto <D.28006>;
      <D.28005>:
      D.27998 = 0;
      return D.27998;
      <D.28006>:
      goto <D.28007>;
      <D.28000>:
      current.54 = (long int) current;
      stack_addr.53 = stack_addr;
      stack_size.56 = stack_size;
      D.28009 = -stack_size.56;
      D.28010 = stack_addr.53 + D.28009;
      D.28011 = (long int) D.28010;
      D.28012 = current.54 - D.28011;
      D.28004 = (long int) min_size;
      if (D.28012 < D.28004) goto <D.28013>; else goto <D.28014>;
      <D.28013>:
      D.27998 = 0;
      return D.27998;
      <D.28014>:
      <D.28007>:
      D.27998 = 1;
      return D.27998;
    }
  finally
    {
      stack_addr = {CLOBBER};
      stack_size = {CLOBBER};
    }
}


ves_icall_System_Runtime_CompilerServices_RuntimeHelpers_RunModuleConstructor (struct MonoImage * image)
{
  long unsigned int D.28017;
  long unsigned int D.28018;
  struct MonoDomain * D.28021;
  struct MonoVTable * D.28022;

  mono_image_check_for_module_cctor (image);
  D.28017 = BIT_FIELD_REF <*image, 64, 192>;
  D.28018 = D.28017 & 549755813888;
  if (D.28018 != 0) goto <D.28019>; else goto <D.28020>;
  <D.28019>:
  {
    struct MonoClass * module_klass;

    module_klass = mono_class_get (image, 33554433);
    D.28021 = mono_domain_get ();
    D.28022 = mono_class_vtable_full (D.28021, module_klass, 1);
    mono_runtime_class_init (D.28022);
  }
  <D.28020>:
}


ves_icall_System_Runtime_CompilerServices_RuntimeHelpers_RunClassConstructor (struct MonoType * handle)
{
  _Bool D.28023;
  long int D.28024;
  long int D.28025;
  _Bool D.28030;
  long int D.28031;
  long int D.28032;
  struct MonoDomain * D.28037;
  struct MonoClass * klass;
  struct MonoVTable * vtable;

  D.28023 = handle == 0B;
  D.28024 = (long int) D.28023;
  D.28025 = __builtin_expect (D.28024, 0);
  if (D.28025 != 0) goto <D.28026>; else goto <D.28027>;
  <D.28026>:
  {
    struct MonoException * ex;

    if (handle != 0B) goto <D.28028>; else goto <D.28029>;
    <D.28028>:
    <D.28029>:
    ex = mono_get_exception_argument_null ("handle");
    mono_raise_exception (ex);
  }
  <D.28027>:
  klass = mono_class_from_mono_type (handle);
  D.28030 = klass == 0B;
  D.28031 = (long int) D.28030;
  D.28032 = __builtin_expect (D.28031, 0);
  if (D.28032 != 0) goto <D.28033>; else goto <D.28034>;
  <D.28033>:
  {
    struct MonoException * ex;
    char * msg;

    msg = monoeg_g_strdup_printf ("assertion `%s\' failed", "klass");
    if (handle != 0B) goto <D.28035>; else goto <D.28036>;
    <D.28035>:
    <D.28036>:
    ex = mono_get_exception_argument ("handle", msg);
    monoeg_g_free (msg);
    mono_raise_exception (ex);
  }
  <D.28034>:
  D.28037 = mono_domain_get ();
  vtable = mono_class_vtable_full (D.28037, klass, 1);
  mono_runtime_class_init (vtable);
}


ves_icall_System_Runtime_CompilerServices_RuntimeHelpers_InitializeArray (struct MonoArray * array, struct MonoClassField * field_handle)
{
  struct MonoVTable * D.28038;
  int D.28039;
  struct MonoClass * D.28040;
  struct MonoType * D.28041;
  int D.28044;
  unsigned char D.28046;
  struct MonoType * D.28047;
  short unsigned int D.28048;
  int D.28049;
  int D.28050;
  unsigned int D.28053;
  int D.28054;
  unsigned int D.28055;
  char * D.28058;
  long unsigned int D.28059;
  struct MonoClass * klass;
  guint32 size;
  struct MonoType * type;
  int align;
  const char * field_data;

  try
    {
      D.28038 = array->obj.vtable;
      klass = D.28038->klass;
      D.28039 = mono_array_element_size (klass);
      size = (guint32) D.28039;
      D.28040 = klass->element_class;
      D.28041 = &D.28040->byval_arg;
      type = mono_type_get_underlying_type (D.28041);
      D.28044 = mono_type_is_reference (type);
      if (D.28044 != 0) goto <D.28042>; else goto <D.28045>;
      <D.28045>:
      D.28046 = type->type;
      if (D.28046 == 17) goto <D.28042>; else goto <D.28043>;
      <D.28042>:
      {
        struct MonoException * exc;

        exc = mono_get_exception_argument ("array", "Cannot initialize array of non-primitive type.");
        mono_raise_exception (exc);
      }
      <D.28043>:
      D.28047 = field_handle->type;
      D.28048 = D.28047->attrs;
      D.28049 = (int) D.28048;
      D.28050 = D.28049 & 256;
      if (D.28050 == 0) goto <D.28051>; else goto <D.28052>;
      <D.28051>:
      {
        struct MonoException * exc;

        exc = mono_get_exception_argument ("field_handle", "Field doesn\'t have an RVA");
        mono_raise_exception (exc);
      }
      <D.28052>:
      D.28053 = array->max_length;
      size = D.28053 * size;
      field_data = mono_field_get_data (field_handle);
      D.28047 = field_handle->type;
      D.28054 = mono_type_size (D.28047, &align);
      D.28055 = (unsigned int) D.28054;
      if (D.28055 < size) goto <D.28056>; else goto <D.28057>;
      <D.28056>:
      {
        struct MonoException * exc;

        exc = mono_get_exception_argument ("field_handle", "Field not large enough to fill array");
        mono_raise_exception (exc);
      }
      <D.28057>:
      D.28058 = mono_array_addr_with_size (array, 1, 0);
      D.28059 = (long unsigned int) size;
      memcpy (D.28058, field_data, D.28059);
    }
  finally
    {
      align = {CLOBBER};
    }
}


ves_icall_System_Runtime_CompilerServices_RuntimeHelpers_GetOffsetToStringData ()
{
  gint D.28060;

  D.28060 = 20;
  return D.28060;
}


ves_icall_System_Runtime_CompilerServices_RuntimeHelpers_GetObjectValue (struct MonoObject * obj)
{
  struct MonoVTable * D.28065;
  struct MonoClass * D.28066;
  long unsigned int D.28067;
  long unsigned int D.28068;
  struct MonoObject * D.28069;

  if (obj == 0B) goto <D.28062>; else goto <D.28064>;
  <D.28064>:
  D.28065 = obj->vtable;
  D.28066 = D.28065->klass;
  D.28067 = BIT_FIELD_REF <*D.28066, 64, 256>;
  D.28068 = D.28067 & 8;
  if (D.28068 == 0) goto <D.28062>; else goto <D.28063>;
  <D.28062>:
  D.28069 = obj;
  return D.28069;
  <D.28063>:
  D.28069 = mono_object_clone (obj);
  return D.28069;
}


param_info_get_type_modifiers (struct MonoReflectionParameter * param, MonoBoolean optional)
{
  struct MonoReflectionType * D.28071;
  struct MonoObject * D.28072;
  struct MonoVTable * D.28073;
  int D.28074;
  struct MonoImage * D.28080;
  struct MonoImage * D.28081;
  int D.24096;
  int iftmp.57;
  int D.24092;
  const char[13] * D.28086;
  unsigned char D.28087;
  int D.28088;
  unsigned char D.28089;
  int D.28090;
  const unsigned char * D.28095;
  unsigned char D.28096;
  int D.28097;
  const unsigned char * D.28098;
  unsigned char D.28099;
  int D.28100;
  const unsigned char * D.28105;
  unsigned char D.28106;
  int D.28107;
  const unsigned char * D.28108;
  unsigned char D.28109;
  int D.28110;
  const unsigned char * D.28115;
  unsigned char D.28116;
  int D.28117;
  const unsigned char * D.28118;
  unsigned char D.28119;
  int D.28120;
  const char * D.28122;
  struct MonoProperty * D.28124;
  _Bool D.28127;
  long int D.28128;
  long int D.28129;
  struct MonoClass * D.28132;
  struct MonoArray * D.28136;
  int D.28137;
  struct MonoType * type;
  struct MonoClass * member_class;
  struct MonoMethod * method;
  struct MonoImage * image;
  int pos;
  struct MonoMethodSignature * sig;

  D.28071 = param->ClassImpl;
  type = D.28071->type;
  D.28072 = param->MemberImpl;
  D.28073 = D.28072->vtable;
  member_class = D.28073->klass;
  method = 0B;
  D.28074 = mono_class_is_reflection_method_or_constructor (member_class);
  if (D.28074 != 0) goto <D.28075>; else goto <D.28076>;
  <D.28075>:
  {
    struct MonoReflectionMethod * rmethod;

    rmethod = param->MemberImpl;
    method = rmethod->method;
  }
  goto <D.28077>;
  <D.28076>:
  D.28080 = member_class->image;
  D.28081 = mono_defaults.corlib;
  if (D.28080 == D.28081) goto <D.28082>; else goto <D.28078>;
  <D.28082>:
  {
    size_t __s1_len;
    size_t __s2_len;

    __s1_len = 12;
    if (__s1_len <= 3) goto <D.28084>; else goto <D.28085>;
    <D.28084>:
    {
      const unsigned char * __s2;
      int __result;

      __s2 = member_class->name;
      D.28086 = "MonoProperty";
      D.28087 = MEM[(const unsigned char *)D.28086];
      D.28088 = (int) D.28087;
      D.28089 = *__s2;
      D.28090 = (int) D.28089;
      __result = D.28088 - D.28090;
      {
        if (__s1_len != 0) goto <D.28091>; else goto <D.28092>;
        <D.28091>:
        if (__result == 0) goto <D.28093>; else goto <D.28094>;
        <D.28093>:
        D.28095 = &MEM[(void *)"MonoProperty" + 1B];
        D.28096 = *D.28095;
        D.28097 = (int) D.28096;
        D.28098 = __s2 + 1;
        D.28099 = *D.28098;
        D.28100 = (int) D.28099;
        __result = D.28097 - D.28100;
        if (__s1_len > 1) goto <D.28101>; else goto <D.28102>;
        <D.28101>:
        if (__result == 0) goto <D.28103>; else goto <D.28104>;
        <D.28103>:
        D.28105 = &MEM[(void *)"MonoProperty" + 2B];
        D.28106 = *D.28105;
        D.28107 = (int) D.28106;
        D.28108 = __s2 + 2;
        D.28109 = *D.28108;
        D.28110 = (int) D.28109;
        __result = D.28107 - D.28110;
        if (__s1_len > 2) goto <D.28111>; else goto <D.28112>;
        <D.28111>:
        if (__result == 0) goto <D.28113>; else goto <D.28114>;
        <D.28113>:
        D.28115 = &MEM[(void *)"MonoProperty" + 3B];
        D.28116 = *D.28115;
        D.28117 = (int) D.28116;
        D.28118 = __s2 + 3;
        D.28119 = *D.28118;
        D.28120 = (int) D.28119;
        __result = D.28117 - D.28120;
        <D.28114>:
        <D.28112>:
        <D.28104>:
        <D.28102>:
        <D.28094>:
        <D.28092>:
      }
      D.24092 = __result;
    }
    iftmp.57 = D.24092;
    goto <D.28121>;
    <D.28085>:
    D.28122 = member_class->name;
    iftmp.57 = __builtin_strcmp ("MonoProperty", D.28122);
    <D.28121>:
    D.24096 = iftmp.57;
  }
  if (D.24096 == 0) goto <D.28123>; else goto <D.28078>;
  <D.28123>:
  {
    struct MonoReflectionProperty * prop;

    prop = param->MemberImpl;
    D.28124 = prop->property;
    method = D.28124->get;
    if (method == 0B) goto <D.28125>; else goto <D.28126>;
    <D.28125>:
    D.28124 = prop->property;
    method = D.28124->set;
    <D.28126>:
    D.28127 = method == 0B;
    D.28128 = (long int) D.28127;
    D.28129 = __builtin_expect (D.28128, 0);
    if (D.28129 != 0) goto <D.28130>; else goto <D.28131>;
    <D.28130>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "icall.c", 7444, "method");
    <D.28131>:
  }
  goto <D.28079>;
  <D.28078>:
  {
    char * type_name;
    char * msg;
    struct MonoException * ex;

    type_name = mono_type_get_full_name (member_class);
    msg = monoeg_g_strdup_printf ("Custom modifiers on a ParamInfo with member %s are not supported", type_name);
    ex = mono_get_exception_not_supported (msg);
    monoeg_g_free (type_name);
    monoeg_g_free (msg);
    mono_raise_exception (ex);
  }
  <D.28079>:
  <D.28077>:
  D.28132 = method->klass;
  image = D.28132->image;
  pos = param->PositionImpl;
  sig = mono_method_signature (method);
  if (pos == -1) goto <D.28133>; else goto <D.28134>;
  <D.28133>:
  type = sig->ret;
  goto <D.28135>;
  <D.28134>:
  type = sig->params[pos];
  <D.28135>:
  D.28137 = (int) optional;
  D.28136 = type_array_from_modifiers (image, type, D.28137);
  return D.28136;
}


type_array_from_modifiers (struct MonoImage * image, struct MonoType * type, int optional)
{
  <unnamed-unsigned:1> D.28143;
  <unnamed-unsigned:6> D.28145;
  int D.28146;
  struct MonoArray * D.28149;
  struct MonoDomain * D.28150;
  struct MonoClass * D.28151;
  long unsigned int D.28152;
  <unnamed-unsigned:31> D.28158;
  unsigned int D.28159;
  struct MonoDomain * D.28160;
  struct MonoType * D.28161;
  struct MonoReflectionType * D.28162;
  struct MonoArray * res;
  int i;
  int count;

  count = 0;
  i = 0;
  goto <D.24070>;
  <D.24069>:
  if (optional != 0) goto <D.28142>; else goto <D.28139>;
  <D.28142>:
  D.28143 = type->modifiers[i].required;
  if (D.28143 == 0) goto <D.28140>; else goto <D.28139>;
  <D.28139>:
  if (optional == 0) goto <D.28144>; else goto <D.28141>;
  <D.28144>:
  D.28143 = type->modifiers[i].required;
  if (D.28143 != 0) goto <D.28140>; else goto <D.28141>;
  <D.28140>:
  count = count + 1;
  <D.28141>:
  i = i + 1;
  <D.24070>:
  D.28145 = type->num_mods;
  D.28146 = (int) D.28145;
  if (D.28146 > i) goto <D.24069>; else goto <D.24071>;
  <D.24071>:
  if (count == 0) goto <D.28147>; else goto <D.28148>;
  <D.28147>:
  D.28149 = 0B;
  return D.28149;
  <D.28148>:
  D.28150 = mono_domain_get ();
  D.28151 = mono_defaults.systemtype_class;
  D.28152 = (long unsigned int) count;
  res = mono_array_new (D.28150, D.28151, D.28152);
  count = 0;
  i = 0;
  goto <D.24075>;
  <D.24074>:
  if (optional != 0) goto <D.28156>; else goto <D.28153>;
  <D.28156>:
  D.28143 = type->modifiers[i].required;
  if (D.28143 == 0) goto <D.28154>; else goto <D.28153>;
  <D.28153>:
  if (optional == 0) goto <D.28157>; else goto <D.28155>;
  <D.28157>:
  D.28143 = type->modifiers[i].required;
  if (D.28143 != 0) goto <D.28154>; else goto <D.28155>;
  <D.28154>:
  {
    struct MonoClass * klass;

    D.28158 = type->modifiers[i].token;
    D.28159 = (unsigned int) D.28158;
    klass = mono_class_get (image, D.28159);
    {
      void * * __p;

      D.28152 = (long unsigned int) count;
      __p = mono_array_addr_with_size (res, 8, D.28152);
      D.28160 = mono_domain_get ();
      D.28161 = &klass->byval_arg;
      D.28162 = mono_type_get_object (D.28160, D.28161);
      mono_gc_wbarrier_set_arrayref (res, __p, D.28162);
    }
    count = count + 1;
  }
  <D.28155>:
  i = i + 1;
  <D.24075>:
  D.28145 = type->num_mods;
  D.28146 = (int) D.28145;
  if (D.28146 > i) goto <D.24074>; else goto <D.24076>;
  <D.24076>:
  D.28149 = res;
  return D.28149;
}


ves_icall_get_property_info (struct MonoReflectionProperty * property, struct MonoPropertyInfo * info, PInfo req_info)
{
  struct MonoVTable * D.28164;
  unsigned int D.28165;
  struct MonoReflectionType * * D.28168;
  struct MonoClass * D.28169;
  struct MonoType * D.28170;
  struct MonoReflectionType * D.28171;
  unsigned int D.28172;
  struct MonoReflectionType * * D.28175;
  struct MonoProperty * D.28176;
  struct MonoClass * D.28177;
  struct MonoType * D.28178;
  struct MonoReflectionType * D.28179;
  unsigned int D.28180;
  struct MonoString * * D.28183;
  const char * D.28184;
  struct MonoString * D.28185;
  unsigned int D.28186;
  unsigned int D.28189;
  unsigned int D.28190;
  struct MonoReflectionMethod * * D.28193;
  struct MonoObject * iftmp.58;
  struct MonoMethod * D.28195;
  unsigned int D.28199;
  struct MonoReflectionMethod * * D.28202;
  struct MonoObject * iftmp.59;
  struct MonoMethod * D.28204;
  struct MonoDomain * domain;

  D.28164 = MEM[(struct MonoObject *)property].vtable;
  domain = D.28164->domain;
  D.28165 = req_info & 8;
  if (D.28165 != 0) goto <D.28166>; else goto <D.28167>;
  <D.28166>:
  D.28168 = &info->parent;
  D.28169 = property->klass;
  D.28170 = &D.28169->byval_arg;
  D.28171 = mono_type_get_object (domain, D.28170);
  mono_gc_wbarrier_generic_store (D.28168, D.28171);
  <D.28167>:
  D.28172 = req_info & 16;
  if (D.28172 != 0) goto <D.28173>; else goto <D.28174>;
  <D.28173>:
  D.28175 = &info->declaring_type;
  D.28176 = property->property;
  D.28177 = D.28176->parent;
  D.28178 = &D.28177->byval_arg;
  D.28179 = mono_type_get_object (domain, D.28178);
  mono_gc_wbarrier_generic_store (D.28175, D.28179);
  <D.28174>:
  D.28180 = req_info & 32;
  if (D.28180 != 0) goto <D.28181>; else goto <D.28182>;
  <D.28181>:
  D.28183 = &info->name;
  D.28176 = property->property;
  D.28184 = D.28176->name;
  D.28185 = mono_string_new (domain, D.28184);
  mono_gc_wbarrier_generic_store (D.28183, D.28185);
  <D.28182>:
  D.28186 = req_info & 1;
  if (D.28186 != 0) goto <D.28187>; else goto <D.28188>;
  <D.28187>:
  D.28176 = property->property;
  D.28189 = D.28176->attrs;
  info->attrs = D.28189;
  <D.28188>:
  D.28190 = req_info & 2;
  if (D.28190 != 0) goto <D.28191>; else goto <D.28192>;
  <D.28191>:
  D.28193 = &info->get;
  D.28176 = property->property;
  D.28195 = D.28176->get;
  if (D.28195 != 0B) goto <D.28196>; else goto <D.28197>;
  <D.28196>:
  D.28176 = property->property;
  D.28195 = D.28176->get;
  D.28169 = property->klass;
  iftmp.58 = mono_method_get_object (domain, D.28195, D.28169);
  goto <D.28198>;
  <D.28197>:
  iftmp.58 = 0B;
  <D.28198>:
  mono_gc_wbarrier_generic_store (D.28193, iftmp.58);
  <D.28192>:
  D.28199 = req_info & 4;
  if (D.28199 != 0) goto <D.28200>; else goto <D.28201>;
  <D.28200>:
  D.28202 = &info->set;
  D.28176 = property->property;
  D.28204 = D.28176->set;
  if (D.28204 != 0B) goto <D.28205>; else goto <D.28206>;
  <D.28205>:
  D.28176 = property->property;
  D.28204 = D.28176->set;
  D.28169 = property->klass;
  iftmp.59 = mono_method_get_object (domain, D.28204, D.28169);
  goto <D.28207>;
  <D.28206>:
  iftmp.59 = 0B;
  <D.28207>:
  mono_gc_wbarrier_generic_store (D.28202, iftmp.59);
  <D.28201>:
}


property_info_get_default_value (struct MonoReflectionProperty * property)
{
  struct MonoVTable * D.28208;
  struct MonoClass * D.28209;
  unsigned int D.28210;
  unsigned int D.28211;
  struct MonoException * D.28214;
  <unnamed type> def_type.60;
  struct MonoObject * D.28216;
  struct MonoType blob_type;
  struct MonoProperty * prop;
  struct MonoType * type;
  struct MonoDomain * domain;
  MonoTypeEnum def_type;
  const char * def_value;
  struct MonoObject * o;

  try
    {
      prop = property->property;
      type = get_property_type (prop);
      D.28208 = MEM[(struct MonoObject *)property].vtable;
      domain = D.28208->domain;
      D.28209 = prop->parent;
      mono_class_init (D.28209);
      D.28210 = prop->attrs;
      D.28211 = D.28210 & 4096;
      if (D.28211 == 0) goto <D.28212>; else goto <D.28213>;
      <D.28212>:
      D.28214 = mono_get_exception_invalid_operation (0B);
      mono_raise_exception (D.28214);
      <D.28213>:
      def_value = mono_class_get_property_default_value (prop, &def_type);
      def_type.60 = def_type;
      mono_type_from_blob_type (&blob_type, def_type.60, type);
      o = mono_get_object_from_blob (domain, &blob_type, def_value);
      D.28216 = o;
      return D.28216;
    }
  finally
    {
      blob_type = {CLOBBER};
      def_type = {CLOBBER};
    }
}


get_property_type (struct MonoProperty * prop)
{
  struct MonoMethod * D.28219;
  struct MonoType * D.28222;
  struct MonoMethod * D.28223;
  short unsigned int D.28226;
  int D.28227;
  int D.28228;
  struct MonoMethodSignature * sig;

  D.28219 = prop->get;
  if (D.28219 != 0B) goto <D.28220>; else goto <D.28221>;
  <D.28220>:
  D.28219 = prop->get;
  sig = mono_method_signature (D.28219);
  D.28222 = sig->ret;
  return D.28222;
  <D.28221>:
  D.28223 = prop->set;
  if (D.28223 != 0B) goto <D.28224>; else goto <D.28225>;
  <D.28224>:
  D.28223 = prop->set;
  sig = mono_method_signature (D.28223);
  D.28226 = sig->param_count;
  D.28227 = (int) D.28226;
  D.28228 = D.28227 + -1;
  D.28222 = sig->params[D.28228];
  return D.28222;
  <D.28225>:
  D.28222 = 0B;
  return D.28222;
}


mono_type_from_blob_type (struct MonoType * type, MonoTypeEnum blob_type, struct MonoType * real_type)
{
  unsigned char D.28230;
  struct MonoClass * D.28233;
  unsigned char D.28237;
  struct MonoClass * D.28239;
  long unsigned int D.28240;
  long unsigned int D.28241;
  struct MonoClass * D.28243;
  struct MonoClass * D.28244;

  D.28230 = (unsigned char) blob_type;
  type->type = D.28230;
  type->data.klass = 0B;
  if (blob_type == 18) goto <D.28231>; else goto <D.28232>;
  <D.28231>:
  D.28233 = mono_defaults.object_class;
  type->data.klass = D.28233;
  goto <D.28234>;
  <D.28232>:
  D.28237 = real_type->type;
  if (D.28237 == 17) goto <D.28238>; else goto <D.28235>;
  <D.28238>:
  D.28239 = real_type->data.klass;
  D.28240 = BIT_FIELD_REF <*D.28239, 64, 256>;
  D.28241 = D.28240 & 16;
  if (D.28241 != 0) goto <D.28242>; else goto <D.28235>;
  <D.28242>:
  type->type = 17;
  D.28243 = mono_class_from_mono_type (real_type);
  type->data.klass = D.28243;
  goto <D.28236>;
  <D.28235>:
  D.28244 = mono_class_from_mono_type (real_type);
  type->data.klass = D.28244;
  <D.28236>:
  <D.28234>:
}


property_info_get_type_modifiers (struct MonoReflectionProperty * property, MonoBoolean optional)
{
  struct MonoProperty * D.28245;
  struct MonoClass * D.28246;
  struct MonoArray * D.28249;
  int D.28250;
  struct MonoType * type;
  struct MonoImage * image;

  D.28245 = property->property;
  type = get_property_type (D.28245);
  D.28246 = property->klass;
  image = D.28246->image;
  if (type == 0B) goto <D.28247>; else goto <D.28248>;
  <D.28247>:
  D.28249 = 0B;
  return D.28249;
  <D.28248>:
  D.28250 = (int) optional;
  D.28249 = type_array_from_modifiers (image, type, D.28250);
  return D.28249;
}


ves_icall_System_MonoMethodInfo_get_retval_marshal (struct MonoMethod * method)
{
  struct MonoMethodSignature * D.28252;
  short unsigned int D.28253;
  int D.28254;
  int D.28255;
  long unsigned int D.28256;
  long unsigned int D.28257;
  struct MonoMarshalSpec * D.28258;
  struct MonoClass * D.28261;
  struct MonoMethodSignature * D.28262;
  short unsigned int D.28263;
  long unsigned int D.28264;
  long unsigned int D.28265;
  struct MonoMarshalSpec * * D.28266;
  struct MonoMarshalSpec * D.28267;
  struct MonoReflectionMarshalAsAttribute * D.28270;
  struct MonoDomain * domain;
  struct MonoReflectionMarshalAsAttribute * res;
  struct MonoMarshalSpec * * mspecs;
  int i;

  domain = mono_domain_get ();
  res = 0B;
  D.28252 = mono_method_signature (method);
  D.28253 = D.28252->param_count;
  D.28254 = (int) D.28253;
  D.28255 = D.28254 + 1;
  D.28256 = (long unsigned int) D.28255;
  D.28257 = D.28256 * 8;
  mspecs = monoeg_malloc (D.28257);
  mono_method_get_marshal_info (method, mspecs);
  D.28258 = *mspecs;
  if (D.28258 != 0B) goto <D.28259>; else goto <D.28260>;
  <D.28259>:
  D.28261 = method->klass;
  D.28258 = *mspecs;
  res = mono_reflection_marshal_as_attribute_from_marshal_spec (domain, D.28261, D.28258);
  <D.28260>:
  D.28262 = mono_method_signature (method);
  D.28263 = D.28262->param_count;
  i = (int) D.28263;
  goto <D.21967>;
  <D.21966>:
  D.28264 = (long unsigned int) i;
  D.28265 = D.28264 * 8;
  D.28266 = mspecs + D.28265;
  D.28267 = *D.28266;
  if (D.28267 != 0B) goto <D.28268>; else goto <D.28269>;
  <D.28268>:
  D.28264 = (long unsigned int) i;
  D.28265 = D.28264 * 8;
  D.28266 = mspecs + D.28265;
  D.28267 = *D.28266;
  mono_metadata_free_marshal_spec (D.28267);
  <D.28269>:
  i = i + -1;
  <D.21967>:
  if (i >= 0) goto <D.21966>; else goto <D.21968>;
  <D.21968>:
  monoeg_g_free (mspecs);
  D.28270 = res;
  return D.28270;
}


ves_icall_get_parameter_info (struct MonoMethod * method, struct MonoReflectionMethod * member)
{
  struct MonoArray * D.28272;
  struct MonoClass * iftmp.61;
  struct MonoReflectionType * D.28274;
  struct MonoType * D.28277;
  struct MonoDomain * domain;

  domain = mono_domain_get ();
  D.28274 = member->reftype;
  if (D.28274 != 0B) goto <D.28275>; else goto <D.28276>;
  <D.28275>:
  D.28274 = member->reftype;
  D.28277 = D.28274->type;
  iftmp.61 = mono_class_from_mono_type (D.28277);
  goto <D.28278>;
  <D.28276>:
  iftmp.61 = 0B;
  <D.28278>:
  D.28272 = mono_param_get_objects_internal (domain, method, iftmp.61);
  return D.28272;
}


ves_icall_get_method_info (struct MonoMethod * method, struct MonoMethodInfo * info)
{
  int D.28280;
  struct MonoReflectionType * * D.28283;
  struct MonoClass * D.28284;
  struct MonoType * D.28285;
  struct MonoReflectionType * D.28286;
  struct MonoReflectionType * * D.28287;
  struct MonoType * D.28288;
  struct MonoReflectionType * D.28289;
  short unsigned int D.28290;
  unsigned int D.28291;
  short unsigned int D.28292;
  unsigned int D.28293;
  long unsigned int D.28294;
  long unsigned int D.28295;
  guint32 iftmp.62;
  short int D.28299;
  unsigned int D.28308;
  <unnamed-unsigned:1> D.28309;
  int D.28310;
  int D.28311;
  <unnamed-unsigned:1> D.28312;
  int D.28313;
  int D.28314;
  int D.28315;
  unsigned int D.28316;
  unsigned int D.28317;
  struct MonoError error;
  struct MonoDomain * domain;
  struct MonoMethodSignature * sig;

  try
    {
      domain = mono_domain_get ();
      sig = mono_method_signature_checked (method, &error);
      D.28280 = mono_error_ok (&error);
      if (D.28280 == 0) goto <D.28281>; else goto <D.28282>;
      <D.28281>:
      mono_error_raise_exception (&error);
      <D.28282>:
      D.28283 = &info->parent;
      D.28284 = method->klass;
      D.28285 = &D.28284->byval_arg;
      D.28286 = mono_type_get_object (domain, D.28285);
      mono_gc_wbarrier_generic_store (D.28283, D.28286);
      D.28287 = &info->ret;
      D.28288 = sig->ret;
      D.28289 = mono_type_get_object (domain, D.28288);
      mono_gc_wbarrier_generic_store (D.28287, D.28289);
      D.28290 = method->flags;
      D.28291 = (unsigned int) D.28290;
      info->attrs = D.28291;
      D.28292 = method->iflags;
      D.28293 = (unsigned int) D.28292;
      info->implattrs = D.28293;
      D.28294 = BIT_FIELD_REF <*sig, 64, 64>;
      D.28295 = D.28294 & 17732923532771328;
      if (D.28295 == 0) goto <D.28296>; else goto <D.28297>;
      <D.28296>:
      D.28299 = sig->sentinelpos;
      if (D.28299 >= 0) goto <D.28300>; else goto <D.28301>;
      <D.28300>:
      iftmp.62 = 2;
      goto <D.28302>;
      <D.28301>:
      iftmp.62 = 1;
      <D.28302>:
      info->callconv = iftmp.62;
      goto <D.28303>;
      <D.28297>:
      D.28294 = BIT_FIELD_REF <*sig, 64, 64>;
      D.28295 = D.28294 & 17732923532771328;
      if (D.28295 == 1407374883553280) goto <D.28304>; else goto <D.28307>;
      <D.28307>:
      D.28299 = sig->sentinelpos;
      if (D.28299 >= 0) goto <D.28304>; else goto <D.28305>;
      <D.28304>:
      info->callconv = 2;
      goto <D.28306>;
      <D.28305>:
      info->callconv = 1;
      <D.28306>:
      <D.28303>:
      D.28308 = info->callconv;
      D.28309 = sig->hasthis;
      D.28310 = (int) D.28309;
      D.28311 = D.28310 << 5;
      D.28312 = sig->explicit_this;
      D.28313 = (int) D.28312;
      D.28314 = D.28313 << 6;
      D.28315 = D.28311 | D.28314;
      D.28316 = (unsigned int) D.28315;
      D.28317 = D.28308 | D.28316;
      info->callconv = D.28317;
    }
  finally
    {
      error = {CLOBBER};
    }
}


vell_icall_get_method_attributes (struct MonoMethod * method)
{
  int D.28318;
  short unsigned int D.28319;

  D.28319 = method->flags;
  D.28318 = (int) D.28319;
  return D.28318;
}


ves_icall_MonoMethod_get_name (struct MonoReflectionMethod * m)
{
  struct MonoString * * D.28321;
  struct MonoVTable * D.28322;
  struct MonoDomain * D.28323;
  const char * D.28324;
  struct MonoString * D.28325;
  struct MonoString * D.28326;
  struct MonoMethod * method;

  method = m->method;
  D.28321 = &m->name;
  D.28322 = MEM[(struct MonoObject *)m].vtable;
  D.28323 = D.28322->domain;
  D.28324 = method->name;
  D.28325 = mono_string_new (D.28323, D.28324);
  mono_gc_wbarrier_set_field (m, D.28321, D.28325);
  D.28326 = m->name;
  return D.28326;
}


ves_icall_MonoMethod_get_base_method (struct MonoReflectionMethod * m, gboolean definition)
{
  struct MonoClass * D.28328;
  struct MonoReflectionMethod * D.28331;
  short unsigned int D.28334;
  int D.28335;
  int D.28336;
  unsigned int D.28338;
  unsigned int D.28339;
  unsigned char D.28341;
  int D.28344;
  struct MonoGenericClass * D.28347;
  int D.28352;
  int D.28359;
  struct MonoMethod * * D.28362;
  long unsigned int D.28363;
  long unsigned int D.28364;
  struct MonoMethod * * D.28365;
  short int D.28368;
  int D.28369;
  struct MonoDomain * D.28373;
  struct MonoClass * klass;
  struct MonoClass * parent;
  struct MonoMethod * method;
  struct MonoMethod * result;
  int slot;

  method = m->method;
  result = 0B;
  D.28328 = method->klass;
  if (D.28328 == 0B) goto <D.28329>; else goto <D.28330>;
  <D.28329>:
  D.28331 = m;
  return D.28331;
  <D.28330>:
  D.28334 = method->flags;
  D.28335 = (int) D.28334;
  D.28336 = D.28335 & 64;
  if (D.28336 == 0) goto <D.28332>; else goto <D.28337>;
  <D.28337>:
  D.28328 = method->klass;
  D.28338 = D.28328->flags;
  D.28339 = D.28338 & 32;
  if (D.28339 != 0) goto <D.28332>; else goto <D.28340>;
  <D.28340>:
  D.28328 = method->klass;
  D.28341 = D.28328->byval_arg.type;
  if (D.28341 == 19) goto <D.28332>; else goto <D.28342>;
  <D.28342>:
  D.28328 = method->klass;
  D.28341 = D.28328->byval_arg.type;
  if (D.28341 == 30) goto <D.28332>; else goto <D.28343>;
  <D.28343>:
  D.28334 = method->flags;
  D.28335 = (int) D.28334;
  D.28344 = D.28335 & 256;
  if (D.28344 != 0) goto <D.28332>; else goto <D.28333>;
  <D.28332>:
  D.28331 = m;
  return D.28331;
  <D.28333>:
  slot = mono_method_get_vtable_slot (method);
  if (slot == -1) goto <D.28345>; else goto <D.28346>;
  <D.28345>:
  D.28331 = m;
  return D.28331;
  <D.28346>:
  klass = method->klass;
  D.28347 = klass->generic_class;
  if (D.28347 != 0B) goto <D.28348>; else goto <D.28349>;
  <D.28348>:
  D.28347 = klass->generic_class;
  klass = D.28347->container_class;
  <D.28349>:
  if (definition != 0) goto <D.28350>; else goto <D.28351>;
  <D.28350>:
  parent = klass->parent;
  goto <D.23971>;
  <D.23970>:
  mono_class_setup_vtable (parent);
  D.28352 = parent->vtable_size;
  if (D.28352 <= slot) goto <D.23969>; else goto <D.28353>;
  <D.28353>:
  klass = parent;
  parent = parent->parent;
  <D.23971>:
  if (parent != 0B) goto <D.23970>; else goto <D.23969>;
  <D.23969>:
  goto <D.28354>;
  <D.28351>:
  klass = klass->parent;
  if (klass == 0B) goto <D.28355>; else goto <D.28356>;
  <D.28355>:
  D.28331 = m;
  return D.28331;
  <D.28356>:
  <D.28354>:
  D.28328 = method->klass;
  if (D.28328 == klass) goto <D.28357>; else goto <D.28358>;
  <D.28357>:
  D.28331 = m;
  return D.28331;
  <D.28358>:
  D.28359 = klass->vtable_size;
  if (D.28359 <= slot) goto <D.28360>; else goto <D.28361>;
  <D.28360>:
  D.28331 = m;
  return D.28331;
  <D.28361>:
  mono_class_setup_vtable (klass);
  D.28362 = klass->vtable;
  D.28363 = (long unsigned int) slot;
  D.28364 = D.28363 * 8;
  D.28365 = D.28362 + D.28364;
  result = *D.28365;
  if (result == 0B) goto <D.28366>; else goto <D.28367>;
  <D.28366>:
  {
    void * iter;

    try
      {
        iter = 0B;
        goto <D.23975>;
        <D.23974>:
        D.28368 = result->slot;
        D.28369 = (int) D.28368;
        if (D.28369 == slot) goto <D.23973>; else goto <D.28370>;
        <D.28370>:
        <D.23975>:
        result = mono_class_get_methods (klass, &iter);
        if (result != 0B) goto <D.23974>; else goto <D.23973>;
        <D.23973>:
      }
    finally
      {
        iter = {CLOBBER};
      }
  }
  <D.28367>:
  if (result == 0B) goto <D.28371>; else goto <D.28372>;
  <D.28371>:
  D.28331 = m;
  return D.28331;
  <D.28372>:
  D.28373 = mono_domain_get ();
  D.28331 = mono_method_get_object (D.28373, result, 0B);
  return D.28331;
}


ves_icall_MonoMethod_get_IsGenericMethodDefinition (struct MonoReflectionMethod * method)
{
  gboolean D.28375;
  struct MonoMethod * D.28376;
  <unnamed-unsigned:1> D.28377;

  D.28376 = method->method;
  D.28377 = D.28376->is_generic;
  D.28375 = (gboolean) D.28377;
  return D.28375;
}


ves_icall_MonoMethod_get_IsGenericMethod (struct MonoReflectionMethod * method)
{
  gboolean D.28379;
  struct MonoMethod * D.28380;
  struct MonoMethodSignature * D.28381;
  short unsigned int D.28382;
  _Bool D.28383;

  D.28380 = method->method;
  D.28381 = mono_method_signature (D.28380);
  D.28382 = D.28381->generic_param_count;
  D.28383 = D.28382 != 0;
  D.28379 = (gboolean) D.28383;
  return D.28379;
}


ves_icall_MonoMethod_GetGenericArguments (struct MonoReflectionMethod * method)
{
  struct MonoVTable * D.28385;
  struct MonoMethod * D.28386;
  long unsigned int D.28387;
  long unsigned int D.28388;
  struct MonoGenericContext * D.28391;
  <unnamed-unsigned:22> D.28394;
  struct MonoClass * D.28395;
  long unsigned int D.28396;
  long unsigned int D.28397;
  struct MonoType * D.28398;
  struct MonoReflectionType * D.28399;
  struct MonoArray * D.28400;
  struct MonoMethodSignature * D.28401;
  short unsigned int D.28402;
  struct MonoGenericParamFull * D.28403;
  long unsigned int D.28404;
  long unsigned int D.28405;
  struct MonoClass * D.28406;
  struct MonoImage * D.28407;
  struct MonoType * D.28408;
  struct MonoReflectionType * D.28409;
  struct MonoArray * res;
  struct MonoDomain * domain;
  int count;
  int i;

  D.28385 = MEM[(struct MonoObject *)method].vtable;
  domain = D.28385->domain;
  D.28386 = method->method;
  D.28387 = BIT_FIELD_REF <*D.28386, 64, 256>;
  D.28388 = D.28387 & 4096;
  if (D.28388 != 0) goto <D.28389>; else goto <D.28390>;
  <D.28389>:
  {
    struct MonoGenericInst * inst;

    D.28386 = method->method;
    D.28391 = mono_method_get_context (D.28386);
    inst = D.28391->method_inst;
    if (inst != 0B) goto <D.28392>; else goto <D.28393>;
    <D.28392>:
    D.28394 = inst->type_argc;
    count = (int) D.28394;
    D.28395 = mono_defaults.systemtype_class;
    D.28396 = (long unsigned int) count;
    res = mono_array_new (domain, D.28395, D.28396);
    i = 0;
    goto <D.22359>;
    <D.22358>:
    {
      void * * __p;

      D.28397 = (long unsigned int) i;
      __p = mono_array_addr_with_size (res, 8, D.28397);
      D.28398 = inst->type_argv[i];
      D.28399 = mono_type_get_object (domain, D.28398);
      mono_gc_wbarrier_set_arrayref (res, __p, D.28399);
    }
    i = i + 1;
    <D.22359>:
    if (i < count) goto <D.22358>; else goto <D.22360>;
    <D.22360>:
    D.28400 = res;
    return D.28400;
    <D.28393>:
  }
  <D.28390>:
  D.28386 = method->method;
  D.28401 = mono_method_signature (D.28386);
  D.28402 = D.28401->generic_param_count;
  count = (int) D.28402;
  D.28395 = mono_defaults.systemtype_class;
  D.28396 = (long unsigned int) count;
  res = mono_array_new (domain, D.28395, D.28396);
  i = 0;
  goto <D.22366>;
  <D.22365>:
  {
    struct MonoGenericContainer * container;
    struct MonoGenericParam * param;
    struct MonoClass * pklass;

    D.28386 = method->method;
    container = mono_method_get_generic_container (D.28386);
    D.28403 = container->type_params;
    D.28404 = (long unsigned int) i;
    D.28405 = D.28404 * 56;
    param = D.28403 + D.28405;
    D.28386 = method->method;
    D.28406 = D.28386->klass;
    D.28407 = D.28406->image;
    pklass = mono_class_from_generic_parameter (param, D.28407, 1);
    {
      void * * __p;

      D.28397 = (long unsigned int) i;
      __p = mono_array_addr_with_size (res, 8, D.28397);
      D.28408 = &pklass->byval_arg;
      D.28409 = mono_type_get_object (domain, D.28408);
      mono_gc_wbarrier_set_arrayref (res, __p, D.28409);
    }
  }
  i = i + 1;
  <D.22366>:
  if (i < count) goto <D.22365>; else goto <D.22367>;
  <D.22367>:
  D.28400 = res;
  return D.28400;
}


ves_icall_MonoMethod_GetDllImportAttribute (struct MonoMethod * method)
{
  struct MonoClass * D.28411;
  short unsigned int D.28412;
  int D.28413;
  int D.28414;
  struct MonoReflectionDllImportAttribute * D.28417;
  struct MonoClass * DllImportAttributeClass.63;
  struct MonoImage * D.28421;
  struct MonoClass * DllImportAttributeClass.64;
  _Bool D.28423;
  long int D.28424;
  long int D.28425;
  struct MonoImage * D.28428;
  long unsigned int D.28429;
  long unsigned int D.28430;
  struct GHashTable * D.28433;
  struct MonoException * D.28439;
  short unsigned int D.28441;
  int D.28444;
  int D.28445;
  unsigned int D.28446;
  short unsigned int D.28447;
  unsigned int D.28448;
  unsigned int D.28449;
  unsigned int D.28450;
  int D.28451;
  short unsigned int D.28452;
  struct MonoString * * D.28453;
  struct MonoString * D.28454;
  struct MonoString * * D.28455;
  struct MonoString * D.28456;
  unsigned int D.28457;
  unsigned int D.28458;
  int D.28459;
  unsigned int D.28460;
  unsigned int D.28461;
  unsigned int D.28462;
  int D.28463;
  int D.28464;
  unsigned int D.28467;
  _Bool D.28468;
  unsigned char D.28469;
  unsigned int D.28470;
  _Bool D.28471;
  unsigned char D.28472;
  unsigned int D.28473;
  _Bool D.28474;
  unsigned char D.28475;
  unsigned int D.28476;
  _Bool D.28477;
  unsigned char D.28478;
  static struct MonoClass * DllImportAttributeClass = 0B;
  struct MonoDomain * domain;
  struct MonoReflectionDllImportAttribute * attr;
  struct MonoImage * image;
  struct MonoMethodPInvoke * piinfo;
  struct MonoTableInfo * tables;
  struct MonoTableInfo * im;
  struct MonoTableInfo * mr;
  guint32 im_cols[4];
  guint32 scope_token;
  const char * import;
  const char * scope;
  guint32 flags;

  try
    {
      domain = mono_domain_get ();
      D.28411 = method->klass;
      image = D.28411->image;
      piinfo = method;
      tables = &image->tables;
      im = tables + 448;
      mr = tables + 416;
      import = 0B;
      scope = 0B;
      D.28412 = method->flags;
      D.28413 = (int) D.28412;
      D.28414 = D.28413 & 8192;
      if (D.28414 == 0) goto <D.28415>; else goto <D.28416>;
      <D.28415>:
      D.28417 = 0B;
      return D.28417;
      <D.28416>:
      DllImportAttributeClass.63 = DllImportAttributeClass;
      if (DllImportAttributeClass.63 == 0B) goto <D.28419>; else goto <D.28420>;
      <D.28419>:
      D.28421 = mono_defaults.corlib;
      DllImportAttributeClass.64 = mono_class_from_name (D.28421, "System.Runtime.InteropServices", "DllImportAttribute");
      DllImportAttributeClass = DllImportAttributeClass.64;
      DllImportAttributeClass.63 = DllImportAttributeClass;
      D.28423 = DllImportAttributeClass.63 == 0B;
      D.28424 = (long int) D.28423;
      D.28425 = __builtin_expect (D.28424, 0);
      if (D.28425 != 0) goto <D.28426>; else goto <D.28427>;
      <D.28426>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "icall.c", 2598, "DllImportAttributeClass");
      <D.28427>:
      <D.28420>:
      D.28411 = method->klass;
      D.28428 = D.28411->image;
      D.28429 = BIT_FIELD_REF <*D.28428, 64, 192>;
      D.28430 = D.28429 & 34359738368;
      if (D.28430 != 0) goto <D.28431>; else goto <D.28432>;
      <D.28431>:
      {
        struct MonoReflectionMethodAux * method_aux;

        D.28411 = method->klass;
        D.28428 = D.28411->image;
        D.28433 = MEM[(struct MonoDynamicImage *)D.28428].method_aux_hash;
        method_aux = monoeg_g_hash_table_lookup (D.28433, method);
        if (method_aux != 0B) goto <D.28434>; else goto <D.28435>;
        <D.28434>:
        import = method_aux->dllentry;
        scope = method_aux->dll;
        <D.28435>:
        if (import == 0B) goto <D.28436>; else goto <D.28438>;
        <D.28438>:
        if (scope == 0B) goto <D.28436>; else goto <D.28437>;
        <D.28436>:
        D.28439 = mono_get_exception_argument ("method", "System.Reflection.Emit method with invalid pinvoke information");
        mono_raise_exception (D.28439);
        D.28417 = 0B;
        return D.28417;
        <D.28437>:
      }
      goto <D.28440>;
      <D.28432>:
      D.28441 = piinfo->implmap_idx;
      if (D.28441 != 0) goto <D.28442>; else goto <D.28443>;
      <D.28442>:
      D.28441 = piinfo->implmap_idx;
      D.28444 = (int) D.28441;
      D.28445 = D.28444 + -1;
      mono_metadata_decode_row (im, D.28445, &im_cols, 4);
      D.28446 = im_cols[0];
      D.28447 = (short unsigned int) D.28446;
      piinfo->piflags = D.28447;
      D.28448 = im_cols[2];
      import = mono_metadata_string_heap (image, D.28448);
      D.28449 = im_cols[3];
      D.28450 = D.28449 + 4294967295;
      D.28451 = (int) D.28450;
      scope_token = mono_metadata_decode_row_col (mr, D.28451, 0);
      scope = mono_metadata_string_heap (image, scope_token);
      <D.28443>:
      <D.28440>:
      D.28452 = piinfo->piflags;
      flags = (guint32) D.28452;
      DllImportAttributeClass.63 = DllImportAttributeClass;
      attr = mono_object_new (domain, DllImportAttributeClass.63);
      D.28453 = &attr->dll;
      D.28454 = mono_string_new (domain, scope);
      mono_gc_wbarrier_set_field (attr, D.28453, D.28454);
      D.28455 = &attr->entry_point;
      D.28456 = mono_string_new (domain, import);
      mono_gc_wbarrier_set_field (attr, D.28455, D.28456);
      D.28457 = flags & 1792;
      D.28458 = D.28457 >> 8;
      D.28459 = (int) D.28458;
      attr->call_conv = D.28459;
      D.28460 = flags & 6;
      D.28461 = D.28460 >> 1;
      D.28462 = D.28461 + 1;
      D.28463 = (int) D.28462;
      attr->charset = D.28463;
      D.28464 = attr->charset;
      if (D.28464 == 1) goto <D.28465>; else goto <D.28466>;
      <D.28465>:
      attr->charset = 2;
      <D.28466>:
      D.28467 = flags & 1;
      D.28468 = D.28467 != 0;
      D.28469 = (unsigned char) D.28468;
      attr->exact_spelling = D.28469;
      D.28470 = flags & 64;
      D.28471 = D.28470 != 0;
      D.28472 = (unsigned char) D.28471;
      attr->set_last_error = D.28472;
      D.28473 = flags & 48;
      D.28474 = D.28473 == 16;
      D.28475 = (unsigned char) D.28474;
      attr->best_fit_mapping = D.28475;
      D.28476 = flags & 12288;
      D.28477 = D.28476 == 4096;
      D.28478 = (unsigned char) D.28477;
      attr->throw_on_unmappable = D.28478;
      attr->preserve_sig = 0;
      D.28417 = attr;
      return D.28417;
    }
  finally
    {
      im_cols = {CLOBBER};
    }
}


ves_icall_MonoGenericMethod_get_ReflectedType (struct MonoReflectionGenericMethod * rmethod)
{
  struct MonoReflectionType * D.28481;
  struct MonoVTable * D.28482;
  struct MonoDomain * D.28483;
  struct MonoClass * D.28484;
  struct MonoType * D.28485;
  struct MonoMethod * method;

  method = rmethod->method.method;
  D.28482 = MEM[(struct MonoObject *)rmethod].vtable;
  D.28483 = D.28482->domain;
  D.28484 = method->klass;
  D.28485 = &D.28484->byval_arg;
  D.28481 = mono_type_get_object (D.28483, D.28485);
  return D.28481;
}


ves_icall_MonoField_SetValueInternal (struct MonoReflectionField * field, struct MonoObject * obj, struct MonoObject * value)
{
  struct MonoClass * D.28487;
  struct MonoImage * D.28488;
  struct MonoAssembly * D.28489;
  int D.28490;
  struct MonoException * D.28493;
  <unnamed type> D.28494;
  int D.28497;
  long unsigned int D.28500;
  long unsigned int D.28501;
  unsigned char D.28504;
  int D.28505;
  struct MonoGenericInst * D.28508;
  long unsigned int D.28509;
  long unsigned int D.28510;
  _Bool D.28511;
  long int D.28512;
  long int D.28513;
  struct MonoClass * D.28516;
  int D.28517;
  struct MonoDomain * D.28520;
  void * D.28521;
  struct MonoClass * D.28523;
  long unsigned int D.28524;
  long unsigned int D.28525;
  short unsigned int D.28530;
  int D.28531;
  int D.28532;
  struct MonoVTable * D.28535;
  struct MonoDomain * D.28536;
  struct MonoClass * D.28537;
  long unsigned int D.28538;
  long unsigned int D.28539;
  struct MonoError error;
  struct MonoClassField * cf;
  struct MonoType * type;
  gchar * v;

  try
    {
      cf = field->field;
      D.28487 = field->klass;
      D.28488 = D.28487->image;
      D.28489 = D.28488->assembly;
      D.28490 = D.28489->ref_only;
      if (D.28490 != 0) goto <D.28491>; else goto <D.28492>;
      <D.28491>:
      D.28493 = mono_get_exception_invalid_operation ("It is illegal to set the value on a field on a type loaded using the ReflectionOnly methods.");
      mono_raise_exception (D.28493);
      <D.28492>:
      D.28494 = mono_security_get_mode ();
      if (D.28494 == 1) goto <D.28495>; else goto <D.28496>;
      <D.28495>:
      mono_security_core_clr_ensure_reflection_access_field (cf);
      <D.28496>:
      type = mono_field_get_type_checked (cf, &error);
      D.28497 = mono_error_ok (&error);
      if (D.28497 == 0) goto <D.28498>; else goto <D.28499>;
      <D.28498>:
      mono_error_raise_exception (&error);
      <D.28499>:
      v = value;
      D.28500 = BIT_FIELD_REF <*type, 64, 64>;
      D.28501 = D.28500 & 1073741824;
      if (D.28501 == 0) goto <D.28502>; else goto <D.28503>;
      <D.28502>:
      D.28504 = type->type;
      D.28505 = (int) D.28504;
      switch (D.28505) <default: <D.22020>, case 2: <D.21996>, case 3: <D.21999>, case 4: <D.21995>, case 5: <D.21994>, case 6: <D.21998>, case 7: <D.21997>, case 8: <D.22003>, case 9: <D.22002>, case 10: <D.22006>, case 11: <D.22005>, case 12: <D.22004>, case 13: <D.22007>, case 14: <D.22011>, case 15: <D.22009>, case 17: <D.22008>, case 18: <D.22013>, case 20: <D.22014>, case 21: <D.22016>, case 24: <D.22001>, case 25: <D.22000>, case 28: <D.22012>, case 29: <D.22015>>
      <D.21994>:
      <D.21995>:
      <D.21996>:
      <D.21997>:
      <D.21998>:
      <D.21999>:
      <D.22000>:
      <D.22001>:
      <D.22002>:
      <D.22003>:
      <D.22004>:
      <D.22005>:
      <D.22006>:
      <D.22007>:
      <D.22008>:
      <D.22009>:
      if (v != 0B) goto <D.28506>; else goto <D.28507>;
      <D.28506>:
      v = v + 16;
      <D.28507>:
      goto <D.22010>;
      <D.22011>:
      <D.22012>:
      <D.22013>:
      <D.22014>:
      <D.22015>:
      goto <D.22010>;
      <D.22016>:
      {
        struct MonoGenericClass * gclass;

        gclass = type->data.generic_class;
        D.28508 = gclass->context.class_inst;
        D.28509 = BIT_FIELD_REF <*D.28508, 64, 0>;
        D.28510 = D.28509 & 18014398509481984;
        D.28511 = D.28510 != 0;
        D.28512 = (long int) D.28511;
        D.28513 = __builtin_expect (D.28512, 0);
        if (D.28513 != 0) goto <D.28514>; else goto <D.28515>;
        <D.28514>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "icall.c", 1825, "!gclass->context.class_inst->is_open");
        <D.28515>:
        D.28516 = mono_class_from_mono_type (type);
        D.28517 = mono_class_is_nullable (D.28516);
        if (D.28517 != 0) goto <D.28518>; else goto <D.28519>;
        <D.28518>:
        {
          struct MonoClass * nklass;
          struct MonoObject * nullable;

          nklass = mono_class_from_mono_type (type);
          D.28520 = mono_domain_get ();
          nullable = mono_object_new (D.28520, nklass);
          D.28521 = mono_object_unbox (nullable);
          mono_nullable_init (D.28521, value, nklass);
          v = mono_object_unbox (nullable);
        }
        goto <D.28522>;
        <D.28519>:
        D.28523 = gclass->container_class;
        D.28524 = BIT_FIELD_REF <*D.28523, 64, 256>;
        D.28525 = D.28524 & 8;
        if (D.28525 != 0) goto <D.28526>; else goto <D.28527>;
        <D.28526>:
        if (v != 0B) goto <D.28528>; else goto <D.28529>;
        <D.28528>:
        v = v + 16;
        <D.28529>:
        <D.28527>:
        <D.28522>:
        goto <D.22010>;
      }
      <D.22020>:
      D.28504 = type->type;
      D.28505 = (int) D.28504;
      monoeg_g_log (0B, 4, "type 0x%x not handled in ves_icall_FieldInfo_SetValueInternal", D.28505);
      <D.22021>:
      goto <D.22021>;
      return;
      <D.22010>:
      <D.28503>:
      D.28530 = type->attrs;
      D.28531 = (int) D.28530;
      D.28532 = D.28531 & 16;
      if (D.28532 != 0) goto <D.28533>; else goto <D.28534>;
      <D.28533>:
      {
        struct MonoVTable * vtable;

        D.28535 = MEM[(struct MonoObject *)field].vtable;
        D.28536 = D.28535->domain;
        D.28537 = cf->parent;
        vtable = mono_class_vtable_full (D.28536, D.28537, 1);
        D.28538 = BIT_FIELD_REF <*vtable, 64, 320>;
        D.28539 = D.28538 & 33554432;
        if (D.28539 == 0) goto <D.28540>; else goto <D.28541>;
        <D.28540>:
        mono_runtime_class_init (vtable);
        <D.28541>:
        mono_field_static_set_value (vtable, cf, v);
      }
      goto <D.28542>;
      <D.28534>:
      mono_field_set_value (obj, cf, v);
      <D.28542>:
    }
  finally
    {
      error = {CLOBBER};
    }
}


ves_icall_MonoField_ResolveType (struct MonoReflectionField * ref_field)
{
  int D.28544;
  struct MonoReflectionType * D.28547;
  struct MonoVTable * D.28548;
  struct MonoDomain * D.28549;
  struct MonoError error;
  struct MonoClassField * field;
  struct MonoType * type;

  try
    {
      field = ref_field->field;
      type = mono_field_get_type_checked (field, &error);
      D.28544 = mono_error_ok (&error);
      if (D.28544 == 0) goto <D.28545>; else goto <D.28546>;
      <D.28545>:
      mono_error_raise_exception (&error);
      <D.28546>:
      D.28548 = MEM[(struct MonoObject *)ref_field].vtable;
      D.28549 = D.28548->domain;
      D.28547 = mono_type_get_object (D.28549, type);
      return D.28547;
    }
  finally
    {
      error = {CLOBBER};
    }
}


ves_icall_MonoField_GetValueInternal (struct MonoReflectionField * field, struct MonoObject * obj)
{
  struct MonoVTable * D.28552;
  struct MonoImage * D.28553;
  struct MonoAssembly * D.28554;
  int D.28555;
  struct MonoException * D.28558;
  <unnamed type> D.28559;
  struct MonoObject * D.28562;
  struct MonoClass * fklass;
  struct MonoClassField * cf;
  struct MonoDomain * domain;

  fklass = field->klass;
  cf = field->field;
  D.28552 = MEM[(struct MonoObject *)field].vtable;
  domain = D.28552->domain;
  D.28553 = fklass->image;
  D.28554 = D.28553->assembly;
  D.28555 = D.28554->ref_only;
  if (D.28555 != 0) goto <D.28556>; else goto <D.28557>;
  <D.28556>:
  D.28558 = mono_get_exception_invalid_operation ("It is illegal to get the value on a field on a type loaded using the ReflectionOnly methods.");
  mono_raise_exception (D.28558);
  <D.28557>:
  D.28559 = mono_security_get_mode ();
  if (D.28559 == 1) goto <D.28560>; else goto <D.28561>;
  <D.28560>:
  mono_security_core_clr_ensure_reflection_access_field (cf);
  <D.28561>:
  D.28562 = mono_field_get_value_object (domain, cf, obj);
  return D.28562;
}


ves_icall_MonoField_GetRawConstantValue (struct MonoReflectionField * this)
{
  struct MonoVTable * D.28564;
  struct MonoClass * D.28565;
  int D.28566;
  short unsigned int D.28569;
  signed short D.28570;
  struct MonoException * D.28573;
  struct MonoImage * D.28574;
  long unsigned int D.28575;
  long unsigned int D.28576;
  struct MonoException * D.28581;
  <unnamed type> def_type.65;
  unsigned char D.28583;
  struct MonoObject * o.66;
  struct MonoObject * o.67;
  struct MonoObject * D.28586;
  struct MonoObject * o;
  struct MonoClassField * field;
  struct MonoClass * klass;
  struct MonoDomain * domain;
  gchar * v;
  MonoTypeEnum def_type;
  const char * def_value;
  struct MonoType * t;
  struct MonoError error;

  try
    {
      o = 0B;
      field = this->field;
      D.28564 = MEM[(struct MonoObject *)this].vtable;
      domain = D.28564->domain;
      D.28565 = field->parent;
      mono_class_init (D.28565);
      t = mono_field_get_type_checked (field, &error);
      D.28566 = mono_error_ok (&error);
      if (D.28566 == 0) goto <D.28567>; else goto <D.28568>;
      <D.28567>:
      mono_error_raise_exception (&error);
      <D.28568>:
      D.28569 = t->attrs;
      D.28570 = (signed short) D.28569;
      if (D.28570 >= 0) goto <D.28571>; else goto <D.28572>;
      <D.28571>:
      D.28573 = mono_get_exception_invalid_operation (0B);
      mono_raise_exception (D.28573);
      <D.28572>:
      D.28565 = field->parent;
      D.28574 = D.28565->image;
      D.28575 = BIT_FIELD_REF <*D.28574, 64, 192>;
      D.28576 = D.28575 & 34359738368;
      if (D.28576 != 0) goto <D.28577>; else goto <D.28578>;
      <D.28577>:
      monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "icall.c", 1890);
      <D.28578>:
      def_value = mono_class_get_field_default_value (field, &def_type);
      if (def_value == 0B) goto <D.28579>; else goto <D.28580>;
      <D.28579>:
      D.28581 = mono_get_exception_invalid_operation (0B);
      mono_raise_exception (D.28581);
      <D.28580>:
      def_type.65 = def_type;
      switch (def_type.65) <default: <D.22053>, case 2: <D.22037>, case 3: <D.22040>, case 4: <D.22036>, case 5: <D.22035>, case 6: <D.22039>, case 7: <D.22038>, case 8: <D.22044>, case 9: <D.22043>, case 10: <D.22047>, case 11: <D.22046>, case 12: <D.22045>, case 13: <D.22048>, case 14: <D.22051>, case 18: <D.22052>, case 24: <D.22042>, case 25: <D.22041>>
      <D.22035>:
      <D.22036>:
      <D.22037>:
      <D.22038>:
      <D.22039>:
      <D.22040>:
      <D.22041>:
      <D.22042>:
      <D.22043>:
      <D.22044>:
      <D.22045>:
      <D.22046>:
      <D.22047>:
      <D.22048>:
      {
        struct MonoType * t;

        t = monoeg_malloc0 (16);
        def_type.65 = def_type;
        D.28583 = (unsigned char) def_type.65;
        t->type = D.28583;
        klass = mono_class_from_mono_type (t);
        monoeg_g_free (t);
        o.66 = mono_object_new (domain, klass);
        o = o.66;
        o.67 = o;
        v = o.67 + 16;
        def_type.65 = def_type;
        mono_get_constant_value_from_blob (domain, def_type.65, def_value, v);
        goto <D.22050>;
      }
      <D.22051>:
      <D.22052>:
      def_type.65 = def_type;
      mono_get_constant_value_from_blob (domain, def_type.65, def_value, &o);
      goto <D.22050>;
      <D.22053>:
      monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "icall.c", 1930);
      <D.22050>:
      D.28586 = o;
      return D.28586;
    }
  finally
    {
      o = {CLOBBER};
      def_type = {CLOBBER};
      error = {CLOBBER};
    }
}


ves_icall_MonoField_GetParentType (struct MonoReflectionField * field, MonoBoolean declaring)
{
  struct MonoClass * iftmp.68;
  struct MonoClassField * D.28592;
  struct MonoReflectionType * D.28594;
  struct MonoVTable * D.28595;
  struct MonoDomain * D.28596;
  struct MonoType * D.28597;
  struct MonoClass * parent;

  if (declaring != 0) goto <D.28590>; else goto <D.28591>;
  <D.28590>:
  D.28592 = field->field;
  iftmp.68 = D.28592->parent;
  goto <D.28593>;
  <D.28591>:
  iftmp.68 = field->klass;
  <D.28593>:
  parent = iftmp.68;
  D.28595 = MEM[(struct MonoObject *)field].vtable;
  D.28596 = D.28595->domain;
  D.28597 = &parent->byval_arg;
  D.28594 = mono_type_get_object (D.28596, D.28597);
  return D.28594;
}


ves_icall_MonoField_GetFieldOffset (struct MonoReflectionField * field)
{
  struct MonoClassField * D.28599;
  long unsigned int D.28600;
  long unsigned int D.28601;
  gint32 D.28604;
  int D.28605;
  unsigned int D.28606;
  unsigned int D.28607;
  struct MonoClass * parent;

  D.28599 = field->field;
  parent = D.28599->parent;
  D.28600 = BIT_FIELD_REF <*parent, 64, 256>;
  D.28601 = D.28600 & 4;
  if (D.28601 == 0) goto <D.28602>; else goto <D.28603>;
  <D.28602>:
  mono_class_init (parent);
  <D.28603>:
  D.28599 = field->field;
  D.28605 = D.28599->offset;
  D.28606 = (unsigned int) D.28605;
  D.28607 = D.28606 + 4294967280;
  D.28604 = (gint32) D.28607;
  return D.28604;
}


ves_icall_get_event_info (struct MonoReflectionMonoEvent * event, struct MonoEventInfo * info)
{
  struct MonoVTable * D.28609;
  struct MonoReflectionType * * D.28610;
  struct MonoClass * D.28611;
  struct MonoType * D.28612;
  struct MonoReflectionType * D.28613;
  struct MonoReflectionType * * D.28614;
  struct MonoEvent * D.28615;
  struct MonoClass * D.28616;
  struct MonoType * D.28617;
  struct MonoReflectionType * D.28618;
  struct MonoString * * D.28619;
  const char * D.28620;
  struct MonoString * D.28621;
  unsigned int D.28622;
  struct MonoReflectionMethod * * D.28623;
  struct MonoObject * iftmp.69;
  struct MonoMethod * D.28625;
  struct MonoReflectionMethod * * D.28629;
  struct MonoObject * iftmp.70;
  struct MonoMethod * D.28631;
  struct MonoReflectionMethod * * D.28635;
  struct MonoObject * iftmp.71;
  struct MonoMethod * D.28637;
  struct MonoMethod * * D.28641;
  long unsigned int D.28644;
  long unsigned int D.28645;
  struct MonoMethod * * D.28646;
  struct MonoMethod * D.28647;
  struct MonoArray * * D.28648;
  struct MonoClass * D.28649;
  long unsigned int D.28650;
  struct MonoArray * D.28651;
  struct MonoArray * D.28652;
  long unsigned int D.28653;
  long unsigned int D.28654;
  long unsigned int D.28655;
  struct MonoMethod * * D.28656;
  struct MonoMethod * D.28657;
  struct MonoReflectionMethod * D.28658;
  struct MonoDomain * domain;

  D.28609 = MEM[(struct MonoObject *)event].vtable;
  domain = D.28609->domain;
  D.28610 = &info->reflected_type;
  D.28611 = event->klass;
  D.28612 = &D.28611->byval_arg;
  D.28613 = mono_type_get_object (domain, D.28612);
  mono_gc_wbarrier_generic_store (D.28610, D.28613);
  D.28614 = &info->declaring_type;
  D.28615 = event->event;
  D.28616 = D.28615->parent;
  D.28617 = &D.28616->byval_arg;
  D.28618 = mono_type_get_object (domain, D.28617);
  mono_gc_wbarrier_generic_store (D.28614, D.28618);
  D.28619 = &info->name;
  D.28615 = event->event;
  D.28620 = D.28615->name;
  D.28621 = mono_string_new (domain, D.28620);
  mono_gc_wbarrier_generic_store (D.28619, D.28621);
  D.28615 = event->event;
  D.28622 = D.28615->attrs;
  info->attrs = D.28622;
  D.28623 = &info->add_method;
  D.28615 = event->event;
  D.28625 = D.28615->add;
  if (D.28625 != 0B) goto <D.28626>; else goto <D.28627>;
  <D.28626>:
  D.28615 = event->event;
  D.28625 = D.28615->add;
  iftmp.69 = mono_method_get_object (domain, D.28625, 0B);
  goto <D.28628>;
  <D.28627>:
  iftmp.69 = 0B;
  <D.28628>:
  mono_gc_wbarrier_generic_store (D.28623, iftmp.69);
  D.28629 = &info->remove_method;
  D.28615 = event->event;
  D.28631 = D.28615->remove;
  if (D.28631 != 0B) goto <D.28632>; else goto <D.28633>;
  <D.28632>:
  D.28615 = event->event;
  D.28631 = D.28615->remove;
  iftmp.70 = mono_method_get_object (domain, D.28631, 0B);
  goto <D.28634>;
  <D.28633>:
  iftmp.70 = 0B;
  <D.28634>:
  mono_gc_wbarrier_generic_store (D.28629, iftmp.70);
  D.28635 = &info->raise_method;
  D.28615 = event->event;
  D.28637 = D.28615->raise;
  if (D.28637 != 0B) goto <D.28638>; else goto <D.28639>;
  <D.28638>:
  D.28615 = event->event;
  D.28637 = D.28615->raise;
  iftmp.71 = mono_method_get_object (domain, D.28637, 0B);
  goto <D.28640>;
  <D.28639>:
  iftmp.71 = 0B;
  <D.28640>:
  mono_gc_wbarrier_generic_store (D.28635, iftmp.71);
  D.28615 = event->event;
  D.28641 = D.28615->other;
  if (D.28641 != 0B) goto <D.28642>; else goto <D.28643>;
  <D.28642>:
  {
    int i;
    int n;

    n = 0;
    goto <D.22086>;
    <D.22085>:
    n = n + 1;
    <D.22086>:
    D.28615 = event->event;
    D.28641 = D.28615->other;
    D.28644 = (long unsigned int) n;
    D.28645 = D.28644 * 8;
    D.28646 = D.28641 + D.28645;
    D.28647 = *D.28646;
    if (D.28647 != 0B) goto <D.22085>; else goto <D.22087>;
    <D.22087>:
    D.28648 = &info->other_methods;
    D.28649 = mono_defaults.method_info_class;
    D.28650 = (long unsigned int) n;
    D.28651 = mono_array_new (domain, D.28649, D.28650);
    mono_gc_wbarrier_generic_store (D.28648, D.28651);
    i = 0;
    goto <D.22090>;
    <D.22089>:
    {
      void * * __p;

      D.28652 = info->other_methods;
      D.28653 = (long unsigned int) i;
      __p = mono_array_addr_with_size (D.28652, 8, D.28653);
      D.28652 = info->other_methods;
      D.28615 = event->event;
      D.28641 = D.28615->other;
      D.28654 = (long unsigned int) i;
      D.28655 = D.28654 * 8;
      D.28656 = D.28641 + D.28655;
      D.28657 = *D.28656;
      D.28658 = mono_method_get_object (domain, D.28657, 0B);
      mono_gc_wbarrier_set_arrayref (D.28652, __p, D.28658);
    }
    i = i + 1;
    <D.22090>:
    if (i < n) goto <D.22089>; else goto <D.22091>;
    <D.22091>:
  }
  <D.28643>:
}


ves_icall_InternalInvoke (struct MonoReflectionMethod * method, struct MonoObject * this, struct MonoArray * params, struct MonoException * * exc)
{
  <unnamed type> D.28659;
  short unsigned int D.28662;
  int D.28663;
  int D.28664;
  struct MonoVTable * D.28667;
  struct MonoDomain * D.28668;
  struct MonoClass * D.28669;
  struct MonoVTable * D.28670;
  struct MonoException * D.28673;
  struct MonoObject * D.28674;
  struct MonoObject * D.28677;
  struct MonoClass * D.28680;
  struct MonoImage * D.28681;
  struct MonoException * D.28682;
  long unsigned int D.28683;
  long unsigned int D.28684;
  int D.22390;
  int iftmp.72;
  int D.22389;
  const char[6] * D.28691;
  unsigned char D.28692;
  int D.28693;
  unsigned char D.28694;
  int D.28695;
  const unsigned char * D.28700;
  unsigned char D.28701;
  int D.28702;
  const unsigned char * D.28703;
  unsigned char D.28704;
  int D.28705;
  const unsigned char * D.28710;
  unsigned char D.28711;
  int D.28712;
  const unsigned char * D.28713;
  unsigned char D.28714;
  int D.28715;
  const unsigned char * D.28720;
  unsigned char D.28721;
  int D.28722;
  const unsigned char * D.28723;
  unsigned char D.28724;
  int D.28725;
  const char * D.28727;
  long unsigned int D.28730;
  long unsigned int D.28731;
  struct MonoException * D.28734;
  struct MonoType * D.28735;
  long unsigned int D.28736;
  long unsigned int D.28737;
  struct MonoException * D.28740;
  int iftmp.73;
  long unsigned int D.28744;
  short unsigned int D.28746;
  int D.28747;
  struct MonoException * D.28750;
  unsigned int D.28751;
  unsigned int D.28752;
  int D.22399;
  int iftmp.74;
  int D.22398;
  unsigned char D.28758;
  int D.28759;
  const unsigned char * D.28764;
  unsigned char D.28765;
  int D.28766;
  const unsigned char * D.28771;
  unsigned char D.28772;
  int D.28773;
  const unsigned char * D.28778;
  unsigned char D.28779;
  int D.28780;
  struct MonoException * D.28786;
  struct MonoAssembly * D.28787;
  int D.28788;
  struct MonoException * D.28791;
  long unsigned int D.28792;
  long unsigned int D.28793;
  int D.28796;
  struct MonoException * D.28799;
  unsigned char D.28800;
  int D.22408;
  int iftmp.75;
  int D.22407;
  unsigned char D.28806;
  int D.28807;
  const unsigned char * D.28812;
  unsigned char D.28813;
  int D.28814;
  const unsigned char * D.28819;
  unsigned char D.28820;
  int D.28821;
  const unsigned char * D.28826;
  unsigned char D.28827;
  int D.28828;
  long unsigned int D.28832;
  long unsigned int D.28833;
  long unsigned int D.28834;
  long unsigned int D.28835;
  long unsigned int D.28836;
  uintptr_t * D.28837;
  long unsigned int D.28838;
  char * D.28839;
  void * D.28840;
  int32_t * D.28841;
  int D.28842;
  long unsigned int D.28843;
  int D.28844;
  int D.28848;
  _Bool D.28849;
  long int D.28850;
  long int D.28851;
  long unsigned int D.28854;
  long unsigned int D.28855;
  struct MonoVTable * D.28856;
  struct MonoDomain * D.28857;
  struct MonoMethod * m;
  struct MonoMethodSignature * sig;
  struct MonoImage * image;
  int pcount;
  void * obj;

  m = method->method;
  sig = mono_method_signature (m);
  obj = this;
  *exc = 0B;
  D.28659 = mono_security_get_mode ();
  if (D.28659 == 1) goto <D.28660>; else goto <D.28661>;
  <D.28660>:
  mono_security_core_clr_ensure_reflection_access_method (m);
  <D.28661>:
  D.28662 = m->flags;
  D.28663 = (int) D.28662;
  D.28664 = D.28663 & 16;
  if (D.28664 == 0) goto <D.28665>; else goto <D.28666>;
  <D.28665>:
  D.28667 = MEM[(struct MonoObject *)method].vtable;
  D.28668 = D.28667->domain;
  D.28669 = m->klass;
  D.28670 = mono_class_vtable_full (D.28668, D.28669, 0);
  if (D.28670 == 0B) goto <D.28671>; else goto <D.28672>;
  <D.28671>:
  D.28669 = m->klass;
  D.28673 = mono_class_get_exception_for_failure (D.28669);
  mono_gc_wbarrier_generic_store (exc, D.28673);
  D.28674 = 0B;
  return D.28674;
  <D.28672>:
  if (this != 0B) goto <D.28675>; else goto <D.28676>;
  <D.28675>:
  D.28669 = m->klass;
  D.28677 = mono_object_isinst (this, D.28669);
  if (D.28677 == 0B) goto <D.28678>; else goto <D.28679>;
  <D.28678>:
  {
    char * this_name;
    char * target_name;
    char * msg;

    D.28680 = mono_object_get_class (this);
    this_name = mono_type_get_full_name (D.28680);
    D.28669 = m->klass;
    target_name = mono_type_get_full_name (D.28669);
    msg = monoeg_g_strdup_printf ("Object of type \'%s\' doesn\'t match target type \'%s\'", this_name, target_name);
    D.28681 = mono_defaults.corlib;
    D.28682 = mono_exception_from_name_msg (D.28681, "System.Reflection", "TargetException", msg);
    mono_gc_wbarrier_generic_store (exc, D.28682);
    monoeg_g_free (msg);
    monoeg_g_free (target_name);
    monoeg_g_free (this_name);
    D.28674 = 0B;
    return D.28674;
  }
  <D.28679>:
  m = mono_object_get_virtual_method (this, m);
  D.28669 = m->klass;
  D.28683 = BIT_FIELD_REF <*D.28669, 64, 256>;
  D.28684 = D.28683 & 8;
  if (D.28684 != 0) goto <D.28685>; else goto <D.28686>;
  <D.28685>:
  obj = mono_object_unbox (this);
  <D.28686>:
  goto <D.28687>;
  <D.28676>:
  {
    size_t __s1_len;
    size_t __s2_len;

    __s2_len = 5;
    if (__s2_len <= 3) goto <D.28689>; else goto <D.28690>;
    <D.28689>:
    {
      const unsigned char * __s2;
      int __result;

      __s2 = m->name;
      D.28691 = ".ctor";
      D.28692 = MEM[(const unsigned char *)D.28691];
      D.28693 = (int) D.28692;
      D.28694 = *__s2;
      D.28695 = (int) D.28694;
      __result = D.28693 - D.28695;
      {
        if (__s2_len != 0) goto <D.28696>; else goto <D.28697>;
        <D.28696>:
        if (__result == 0) goto <D.28698>; else goto <D.28699>;
        <D.28698>:
        D.28700 = &MEM[(void *)".ctor" + 1B];
        D.28701 = *D.28700;
        D.28702 = (int) D.28701;
        D.28703 = __s2 + 1;
        D.28704 = *D.28703;
        D.28705 = (int) D.28704;
        __result = D.28702 - D.28705;
        if (__s2_len > 1) goto <D.28706>; else goto <D.28707>;
        <D.28706>:
        if (__result == 0) goto <D.28708>; else goto <D.28709>;
        <D.28708>:
        D.28710 = &MEM[(void *)".ctor" + 2B];
        D.28711 = *D.28710;
        D.28712 = (int) D.28711;
        D.28713 = __s2 + 2;
        D.28714 = *D.28713;
        D.28715 = (int) D.28714;
        __result = D.28712 - D.28715;
        if (__s2_len > 2) goto <D.28716>; else goto <D.28717>;
        <D.28716>:
        if (__result == 0) goto <D.28718>; else goto <D.28719>;
        <D.28718>:
        D.28720 = &MEM[(void *)".ctor" + 3B];
        D.28721 = *D.28720;
        D.28722 = (int) D.28721;
        D.28723 = __s2 + 3;
        D.28724 = *D.28723;
        D.28725 = (int) D.28724;
        __result = D.28722 - D.28725;
        <D.28719>:
        <D.28717>:
        <D.28709>:
        <D.28707>:
        <D.28699>:
        <D.28697>:
      }
      D.22389 = __result;
    }
    iftmp.72 = -D.22389;
    goto <D.28726>;
    <D.28690>:
    D.28727 = m->name;
    iftmp.72 = __builtin_strcmp (D.28727, ".ctor");
    <D.28726>:
    D.22390 = iftmp.72;
  }
  if (D.22390 != 0) goto <D.28728>; else goto <D.28729>;
  <D.28728>:
  D.28730 = BIT_FIELD_REF <*m, 64, 256>;
  D.28731 = D.28730 & 124;
  if (D.28731 == 0) goto <D.28732>; else goto <D.28733>;
  <D.28732>:
  D.28681 = mono_defaults.corlib;
  D.28734 = mono_exception_from_name_msg (D.28681, "System.Reflection", "TargetException", "Non-static method requires a target.");
  mono_gc_wbarrier_generic_store (exc, D.28734);
  D.28674 = 0B;
  return D.28674;
  <D.28733>:
  <D.28729>:
  <D.28687>:
  <D.28666>:
  D.28735 = sig->ret;
  D.28736 = BIT_FIELD_REF <*D.28735, 64, 64>;
  D.28737 = D.28736 & 1073741824;
  if (D.28737 != 0) goto <D.28738>; else goto <D.28739>;
  <D.28738>:
  D.28681 = mono_defaults.corlib;
  D.28740 = mono_exception_from_name_msg (D.28681, "System", "NotSupportedException", "Cannot invoke method returning ByRef type via reflection");
  mono_gc_wbarrier_generic_store (exc, D.28740);
  D.28674 = 0B;
  return D.28674;
  <D.28739>:
  if (params != 0B) goto <D.28742>; else goto <D.28743>;
  <D.28742>:
  D.28744 = mono_array_length (params);
  iftmp.73 = (int) D.28744;
  goto <D.28745>;
  <D.28743>:
  iftmp.73 = 0;
  <D.28745>:
  pcount = iftmp.73;
  D.28746 = sig->param_count;
  D.28747 = (int) D.28746;
  if (D.28747 != pcount) goto <D.28748>; else goto <D.28749>;
  <D.28748>:
  D.28681 = mono_defaults.corlib;
  D.28750 = mono_exception_from_name (D.28681, "System.Reflection", "TargetParameterCountException");
  mono_gc_wbarrier_generic_store (exc, D.28750);
  D.28674 = 0B;
  return D.28674;
  <D.28749>:
  D.28669 = m->klass;
  D.28751 = D.28669->flags;
  D.28752 = D.28751 & 128;
  if (D.28752 != 0) goto <D.28753>; else goto <D.28754>;
  <D.28753>:
  {
    size_t __s1_len;
    size_t __s2_len;

    __s2_len = 5;
    if (__s2_len <= 3) goto <D.28756>; else goto <D.28757>;
    <D.28756>:
    {
      const unsigned char * __s2;
      int __result;

      __s2 = m->name;
      D.28691 = ".ctor";
      D.28692 = MEM[(const unsigned char *)D.28691];
      D.28693 = (int) D.28692;
      D.28758 = *__s2;
      D.28759 = (int) D.28758;
      __result = D.28693 - D.28759;
      {
        if (__s2_len != 0) goto <D.28760>; else goto <D.28761>;
        <D.28760>:
        if (__result == 0) goto <D.28762>; else goto <D.28763>;
        <D.28762>:
        D.28700 = &MEM[(void *)".ctor" + 1B];
        D.28701 = *D.28700;
        D.28702 = (int) D.28701;
        D.28764 = __s2 + 1;
        D.28765 = *D.28764;
        D.28766 = (int) D.28765;
        __result = D.28702 - D.28766;
        if (__s2_len > 1) goto <D.28767>; else goto <D.28768>;
        <D.28767>:
        if (__result == 0) goto <D.28769>; else goto <D.28770>;
        <D.28769>:
        D.28710 = &MEM[(void *)".ctor" + 2B];
        D.28711 = *D.28710;
        D.28712 = (int) D.28711;
        D.28771 = __s2 + 2;
        D.28772 = *D.28771;
        D.28773 = (int) D.28772;
        __result = D.28712 - D.28773;
        if (__s2_len > 2) goto <D.28774>; else goto <D.28775>;
        <D.28774>:
        if (__result == 0) goto <D.28776>; else goto <D.28777>;
        <D.28776>:
        D.28720 = &MEM[(void *)".ctor" + 3B];
        D.28721 = *D.28720;
        D.28722 = (int) D.28721;
        D.28778 = __s2 + 3;
        D.28779 = *D.28778;
        D.28780 = (int) D.28779;
        __result = D.28722 - D.28780;
        <D.28777>:
        <D.28775>:
        <D.28770>:
        <D.28768>:
        <D.28763>:
        <D.28761>:
      }
      D.22398 = __result;
    }
    iftmp.74 = -D.22398;
    goto <D.28781>;
    <D.28757>:
    D.28727 = m->name;
    iftmp.74 = __builtin_strcmp (D.28727, ".ctor");
    <D.28781>:
    D.22399 = iftmp.74;
  }
  if (D.22399 == 0) goto <D.28782>; else goto <D.28783>;
  <D.28782>:
  if (this == 0B) goto <D.28784>; else goto <D.28785>;
  <D.28784>:
  D.28681 = mono_defaults.corlib;
  D.28786 = mono_exception_from_name_msg (D.28681, "System.Reflection", "TargetException", "Cannot invoke constructor of an abstract class.");
  mono_gc_wbarrier_generic_store (exc, D.28786);
  D.28674 = 0B;
  return D.28674;
  <D.28785>:
  <D.28783>:
  <D.28754>:
  D.28669 = m->klass;
  image = D.28669->image;
  D.28787 = image->assembly;
  D.28788 = D.28787->ref_only;
  if (D.28788 != 0) goto <D.28789>; else goto <D.28790>;
  <D.28789>:
  D.28791 = mono_get_exception_invalid_operation ("It is illegal to invoke a method on a type loaded using the ReflectionOnly api.");
  mono_gc_wbarrier_generic_store (exc, D.28791);
  D.28674 = 0B;
  return D.28674;
  <D.28790>:
  D.28792 = BIT_FIELD_REF <*image, 64, 192>;
  D.28793 = D.28792 & 34359738368;
  if (D.28793 != 0) goto <D.28794>; else goto <D.28795>;
  <D.28794>:
  D.28796 = MEM[(struct MonoDynamicImage *)image].run;
  if (D.28796 == 0) goto <D.28797>; else goto <D.28798>;
  <D.28797>:
  D.28799 = mono_get_exception_not_supported ("Cannot invoke a method in a dynamic assembly without run access.");
  mono_gc_wbarrier_generic_store (exc, D.28799);
  D.28674 = 0B;
  return D.28674;
  <D.28798>:
  <D.28795>:
  D.28669 = m->klass;
  D.28800 = D.28669->rank;
  if (D.28800 != 0) goto <D.28801>; else goto <D.28802>;
  <D.28801>:
  {
    size_t __s1_len;
    size_t __s2_len;

    __s2_len = 5;
    if (__s2_len <= 3) goto <D.28804>; else goto <D.28805>;
    <D.28804>:
    {
      const unsigned char * __s2;
      int __result;

      __s2 = m->name;
      D.28691 = ".ctor";
      D.28692 = MEM[(const unsigned char *)D.28691];
      D.28693 = (int) D.28692;
      D.28806 = *__s2;
      D.28807 = (int) D.28806;
      __result = D.28693 - D.28807;
      {
        if (__s2_len != 0) goto <D.28808>; else goto <D.28809>;
        <D.28808>:
        if (__result == 0) goto <D.28810>; else goto <D.28811>;
        <D.28810>:
        D.28700 = &MEM[(void *)".ctor" + 1B];
        D.28701 = *D.28700;
        D.28702 = (int) D.28701;
        D.28812 = __s2 + 1;
        D.28813 = *D.28812;
        D.28814 = (int) D.28813;
        __result = D.28702 - D.28814;
        if (__s2_len > 1) goto <D.28815>; else goto <D.28816>;
        <D.28815>:
        if (__result == 0) goto <D.28817>; else goto <D.28818>;
        <D.28817>:
        D.28710 = &MEM[(void *)".ctor" + 2B];
        D.28711 = *D.28710;
        D.28712 = (int) D.28711;
        D.28819 = __s2 + 2;
        D.28820 = *D.28819;
        D.28821 = (int) D.28820;
        __result = D.28712 - D.28821;
        if (__s2_len > 2) goto <D.28822>; else goto <D.28823>;
        <D.28822>:
        if (__result == 0) goto <D.28824>; else goto <D.28825>;
        <D.28824>:
        D.28720 = &MEM[(void *)".ctor" + 3B];
        D.28721 = *D.28720;
        D.28722 = (int) D.28721;
        D.28826 = __s2 + 3;
        D.28827 = *D.28826;
        D.28828 = (int) D.28827;
        __result = D.28722 - D.28828;
        <D.28825>:
        <D.28823>:
        <D.28818>:
        <D.28816>:
        <D.28811>:
        <D.28809>:
      }
      D.22407 = __result;
    }
    iftmp.75 = -D.22407;
    goto <D.28829>;
    <D.28805>:
    D.28727 = m->name;
    iftmp.75 = __builtin_strcmp (D.28727, ".ctor");
    <D.28829>:
    D.22408 = iftmp.75;
  }
  if (D.22408 == 0) goto <D.28830>; else goto <D.28831>;
  <D.28830>:
  {
    int i;
    uintptr_t * lengths;
    intptr_t * lower_bounds;

    D.28832 = mono_array_length (params);
    pcount = (int) D.28832;
    D.28833 = (long unsigned int) pcount;
    D.28834 = D.28833 * 8;
    lengths = __builtin_alloca (D.28834);
    i = 0;
    goto <D.22413>;
    <D.22412>:
    D.28835 = (long unsigned int) i;
    D.28836 = D.28835 * 8;
    D.28837 = lengths + D.28836;
    D.28838 = (long unsigned int) i;
    D.28839 = mono_array_addr_with_size (params, 8, D.28838);
    D.28840 = MEM[(void * *)D.28839];
    D.28841 = D.28840 + 16;
    D.28842 = *D.28841;
    D.28843 = (long unsigned int) D.28842;
    *D.28837 = D.28843;
    i = i + 1;
    <D.22413>:
    if (i < pcount) goto <D.22412>; else goto <D.22414>;
    <D.22414>:
    D.28669 = m->klass;
    D.28800 = D.28669->rank;
    D.28844 = (int) D.28800;
    if (D.28844 == pcount) goto <D.28845>; else goto <D.28846>;
    <D.28845>:
    lower_bounds = 0B;
    goto <D.28847>;
    <D.28846>:
    D.28669 = m->klass;
    D.28800 = D.28669->rank;
    D.28844 = (int) D.28800;
    D.28848 = D.28844 * 2;
    D.28849 = D.28848 != pcount;
    D.28850 = (long int) D.28849;
    D.28851 = __builtin_expect (D.28850, 0);
    if (D.28851 != 0) goto <D.28852>; else goto <D.28853>;
    <D.28852>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "icall.c", 2835, "pcount == (m->klass->rank * 2)");
    <D.28853>:
    lower_bounds = lengths;
    D.28669 = m->klass;
    D.28800 = D.28669->rank;
    D.28854 = (long unsigned int) D.28800;
    D.28855 = D.28854 * 8;
    lengths = lengths + D.28855;
    <D.28847>:
    D.28856 = MEM[(struct MonoObject *)params].vtable;
    D.28857 = D.28856->domain;
    D.28669 = m->klass;
    D.28674 = mono_array_new_full (D.28857, D.28669, lengths, lower_bounds);
    return D.28674;
  }
  <D.28831>:
  <D.28802>:
  D.28674 = mono_runtime_invoke_array (m, obj, params, 0B);
  return D.28674;
}


ves_icall_MonoMethod_GetGenericMethodDefinition (struct MonoReflectionMethod * method)
{
  struct MonoMethod * D.28859;
  long unsigned int D.28860;
  long unsigned int D.28861;
  struct MonoReflectionMethod * D.28864;
  long unsigned int D.28865;
  long unsigned int D.28868;
  long unsigned int D.28869;
  struct MonoClass * D.28872;
  struct MonoImage * D.28873;
  long unsigned int D.28874;
  long unsigned int D.28875;
  struct MonoGHashTable * D.28878;
  struct MonoGenericInst * D.28881;
  struct MonoGenericContext * D.28884;
  struct MonoGenericContext * D.28887;
  struct MonoVTable * D.28888;
  struct MonoDomain * D.28889;
  struct MonoMethodInflated * imethod;
  struct MonoMethod * result;

  D.28859 = method->method;
  D.28860 = BIT_FIELD_REF <*D.28859, 64, 256>;
  D.28861 = D.28860 & 2048;
  if (D.28861 != 0) goto <D.28862>; else goto <D.28863>;
  <D.28862>:
  D.28864 = method;
  return D.28864;
  <D.28863>:
  D.28859 = method->method;
  D.28860 = BIT_FIELD_REF <*D.28859, 64, 256>;
  D.28865 = D.28860 & 4096;
  if (D.28865 == 0) goto <D.28866>; else goto <D.28867>;
  <D.28866>:
  D.28864 = 0B;
  return D.28864;
  <D.28867>:
  imethod = method->method;
  result = imethod->declaring;
  D.28868 = BIT_FIELD_REF <*result, 64, 256>;
  D.28869 = D.28868 & 2048;
  if (D.28869 == 0) goto <D.28870>; else goto <D.28871>;
  <D.28870>:
  D.28864 = 0B;
  return D.28864;
  <D.28871>:
  D.28859 = method->method;
  D.28872 = D.28859->klass;
  D.28873 = D.28872->image;
  D.28874 = BIT_FIELD_REF <*D.28873, 64, 192>;
  D.28875 = D.28874 & 34359738368;
  if (D.28875 != 0) goto <D.28876>; else goto <D.28877>;
  <D.28876>:
  {
    struct MonoDynamicImage * image;
    struct MonoReflectionMethod * res;

    D.28859 = method->method;
    D.28872 = D.28859->klass;
    image = D.28872->image;
    mono_image_lock (image);
    D.28878 = image->generic_def_objects;
    res = mono_g_hash_table_lookup (D.28878, imethod);
    mono_image_unlock (image);
    if (res != 0B) goto <D.28879>; else goto <D.28880>;
    <D.28879>:
    D.28864 = res;
    return D.28864;
    <D.28880>:
  }
  <D.28877>:
  D.28881 = imethod->context.class_inst;
  if (D.28881 != 0B) goto <D.28882>; else goto <D.28883>;
  <D.28882>:
  {
    struct MonoClass * klass;

    klass = MEM[(struct MonoMethod *)imethod].klass;
    D.28884 = mono_class_get_context (klass);
    if (D.28884 != 0B) goto <D.28885>; else goto <D.28886>;
    <D.28885>:
    D.28887 = mono_class_get_context (klass);
    result = mono_class_inflate_generic_method_full (result, klass, D.28887);
    <D.28886>:
  }
  <D.28883>:
  D.28888 = MEM[(struct MonoObject *)method].vtable;
  D.28889 = D.28888->domain;
  D.28864 = mono_method_get_object (D.28889, result, 0B);
  return D.28864;
}


ves_icall_System_Reflection_Module_ResolveTypeToken (struct MonoImage * image, guint32 token, struct MonoArray * type_args, struct MonoArray * method_args, MonoResolveTokenError * error)
{
  unsigned int D.28891;
  int token.76;
  unsigned int table.77;
  unsigned int D.28894;
  struct MonoType * D.28899;
  long unsigned int D.28900;
  long unsigned int D.28901;
  struct MonoType * iftmp.78;
  struct MonoType * iftmp.79;
  <unnamed-unsigned:24> D.28917;
  int D.28918;
  struct MonoLoaderError * D.28919;
  struct MonoLoaderError * D.28922;
  struct MonoException * D.28923;
  struct MonoClass * klass;
  int table;
  int index;
  struct MonoGenericContext context;

  try
    {
      D.28891 = token >> 24;
      table = (int) D.28891;
      token.76 = (int) token;
      index = token.76 & 16777215;
      *error = 2;
      table.77 = (unsigned int) table;
      D.28894 = table.77 + 4294967295;
      if (D.28894 > 1) goto <D.28895>; else goto <D.28896>;
      <D.28895>:
      if (table != 27) goto <D.28897>; else goto <D.28898>;
      <D.28897>:
      *error = 1;
      D.28899 = 0B;
      return D.28899;
      <D.28898>:
      <D.28896>:
      D.28900 = BIT_FIELD_REF <*image, 64, 192>;
      D.28901 = D.28900 & 34359738368;
      if (D.28901 != 0) goto <D.28902>; else goto <D.28903>;
      <D.28902>:
      table.77 = (unsigned int) table;
      D.28894 = table.77 + 4294967295;
      if (D.28894 <= 1) goto <D.28904>; else goto <D.28905>;
      <D.28904>:
      klass = mono_lookup_dynamic_token_class (image, token, 0, 0B, 0B);
      if (klass != 0B) goto <D.28907>; else goto <D.28908>;
      <D.28907>:
      iftmp.78 = &klass->byval_arg;
      goto <D.28909>;
      <D.28908>:
      iftmp.78 = 0B;
      <D.28909>:
      D.28899 = iftmp.78;
      return D.28899;
      <D.28905>:
      init_generic_context_from_args (&context, type_args, method_args);
      klass = mono_lookup_dynamic_token_class (image, token, 0, 0B, &context);
      if (klass != 0B) goto <D.28911>; else goto <D.28912>;
      <D.28911>:
      iftmp.79 = &klass->byval_arg;
      goto <D.28913>;
      <D.28912>:
      iftmp.79 = 0B;
      <D.28913>:
      D.28899 = iftmp.79;
      return D.28899;
      <D.28903>:
      if (index <= 0) goto <D.28914>; else goto <D.28916>;
      <D.28916>:
      D.28917 = image->tables[table].rows;
      D.28918 = (int) D.28917;
      if (D.28918 < index) goto <D.28914>; else goto <D.28915>;
      <D.28914>:
      *error = 0;
      D.28899 = 0B;
      return D.28899;
      <D.28915>:
      init_generic_context_from_args (&context, type_args, method_args);
      klass = mono_class_get_full (image, token, &context);
      D.28919 = mono_loader_get_last_error ();
      if (D.28919 != 0B) goto <D.28920>; else goto <D.28921>;
      <D.28920>:
      D.28922 = mono_loader_get_last_error ();
      D.28923 = mono_loader_error_prepare_exception (D.28922);
      mono_raise_exception (D.28923);
      <D.28921>:
      if (klass != 0B) goto <D.28924>; else goto <D.28925>;
      <D.28924>:
      D.28899 = &klass->byval_arg;
      return D.28899;
      <D.28925>:
      D.28899 = 0B;
      return D.28899;
    }
  finally
    {
      context = {CLOBBER};
    }
}


init_generic_context_from_args (struct MonoGenericContext * context, struct MonoArray * type_args, struct MonoArray * method_args)
{
  long unsigned int D.28930;
  int D.28931;
  char * D.28932;
  struct MonoGenericInst * D.28933;
  long unsigned int D.28937;
  int D.28938;
  char * D.28939;
  struct MonoGenericInst * D.28940;

  if (type_args != 0B) goto <D.28928>; else goto <D.28929>;
  <D.28928>:
  D.28930 = mono_array_length (type_args);
  D.28931 = (int) D.28930;
  D.28932 = mono_array_addr_with_size (type_args, 8, 0);
  D.28933 = mono_metadata_get_generic_inst (D.28931, D.28932);
  context->class_inst = D.28933;
  goto <D.28934>;
  <D.28929>:
  context->class_inst = 0B;
  <D.28934>:
  if (method_args != 0B) goto <D.28935>; else goto <D.28936>;
  <D.28935>:
  D.28937 = mono_array_length (method_args);
  D.28938 = (int) D.28937;
  D.28939 = mono_array_addr_with_size (method_args, 8, 0);
  D.28940 = mono_metadata_get_generic_inst (D.28938, D.28939);
  context->method_inst = D.28940;
  goto <D.28941>;
  <D.28936>:
  context->method_inst = 0B;
  <D.28941>:
}


ves_icall_System_Reflection_Module_ResolveStringToken (struct MonoImage * image, guint32 token, MonoResolveTokenError * error)
{
  int token.80;
  unsigned int D.28943;
  struct MonoString * D.28946;
  long unsigned int D.28947;
  long unsigned int D.28948;
  unsigned int index.81;
  unsigned int D.28955;
  struct MonoDomain * D.28956;
  unsigned int index.82;
  int index;

  token.80 = (int) token;
  index = token.80 & 16777215;
  *error = 2;
  D.28943 = token & 4278190080;
  if (D.28943 != 1879048192) goto <D.28944>; else goto <D.28945>;
  <D.28944>:
  *error = 1;
  D.28946 = 0B;
  return D.28946;
  <D.28945>:
  D.28947 = BIT_FIELD_REF <*image, 64, 192>;
  D.28948 = D.28947 & 34359738368;
  if (D.28948 != 0) goto <D.28949>; else goto <D.28950>;
  <D.28949>:
  D.28946 = mono_lookup_dynamic_token_class (image, token, 0, 0B, 0B);
  return D.28946;
  <D.28950>:
  if (index <= 0) goto <D.28951>; else goto <D.28953>;
  <D.28953>:
  index.81 = (unsigned int) index;
  D.28955 = image->heap_us.size;
  if (index.81 >= D.28955) goto <D.28951>; else goto <D.28952>;
  <D.28951>:
  *error = 0;
  D.28946 = 0B;
  return D.28946;
  <D.28952>:
  D.28956 = mono_domain_get ();
  index.82 = (unsigned int) index;
  D.28946 = mono_ldstr (D.28956, image, index.82);
  return D.28946;
}


ves_icall_System_Reflection_Module_ResolveSignature (struct MonoImage * image, guint32 token, MonoResolveTokenError * error)
{
  unsigned int D.28959;
  int token.83;
  struct MonoArray * D.28963;
  long unsigned int D.28964;
  long unsigned int D.28965;
  struct MonoTableInfo * D.28971;
  <unnamed-unsigned:24> D.28972;
  int D.28973;
  const struct MonoTableInfo * D.28974;
  int D.28975;
  const char * ptr.84;
  const char * ptr.85;
  struct MonoDomain * D.28978;
  struct MonoClass * D.28979;
  long unsigned int D.28980;
  char * D.28981;
  long unsigned int D.28982;
  int table;
  int idx;
  struct MonoTableInfo * tables;
  guint32 sig;
  guint32 len;
  const char * ptr;
  struct MonoArray * res;

  try
    {
      D.28959 = token >> 24;
      table = (int) D.28959;
      token.83 = (int) token;
      idx = token.83 & 16777215;
      tables = &image->tables;
      *error = 0;
      if (table != 17) goto <D.28961>; else goto <D.28962>;
      <D.28961>:
      D.28963 = 0B;
      return D.28963;
      <D.28962>:
      D.28964 = BIT_FIELD_REF <*image, 64, 192>;
      D.28965 = D.28964 & 34359738368;
      if (D.28965 != 0) goto <D.28966>; else goto <D.28967>;
      <D.28966>:
      D.28963 = 0B;
      return D.28963;
      <D.28967>:
      if (idx == 0) goto <D.28968>; else goto <D.28970>;
      <D.28970>:
      D.28971 = tables + 272;
      D.28972 = D.28971->rows;
      D.28973 = (int) D.28972;
      if (D.28973 < idx) goto <D.28968>; else goto <D.28969>;
      <D.28968>:
      D.28963 = 0B;
      return D.28963;
      <D.28969>:
      D.28974 = tables + 272;
      D.28975 = idx + -1;
      sig = mono_metadata_decode_row_col (D.28974, D.28975, 0);
      ptr.84 = mono_metadata_blob_heap (image, sig);
      ptr = ptr.84;
      ptr.85 = ptr;
      len = mono_metadata_decode_blob_size (ptr.85, &ptr);
      D.28978 = mono_domain_get ();
      D.28979 = mono_defaults.byte_class;
      D.28980 = (long unsigned int) len;
      res = mono_array_new (D.28978, D.28979, D.28980);
      D.28981 = mono_array_addr_with_size (res, 1, 0);
      ptr.85 = ptr;
      D.28982 = (long unsigned int) len;
      memcpy (D.28981, ptr.85, D.28982);
      D.28963 = res;
      return D.28963;
    }
  finally
    {
      ptr = {CLOBBER};
    }
}


ves_icall_System_Reflection_Module_ResolveMethodToken (struct MonoImage * image, guint32 token, struct MonoArray * type_args, struct MonoArray * method_args, MonoResolveTokenError * error)
{
  unsigned int D.28985;
  int token.86;
  struct MonoMethod * D.28993;
  long unsigned int D.28994;
  long unsigned int D.28995;
  int D.29002;
  <unnamed-unsigned:24> D.29008;
  int D.29009;
  int D.29012;
  struct MonoLoaderError * D.29015;
  struct MonoLoaderError * D.29018;
  struct MonoException * D.29019;
  int table;
  int index;
  struct MonoGenericContext context;
  struct MonoMethod * method;

  try
    {
      D.28985 = token >> 24;
      table = (int) D.28985;
      token.86 = (int) token;
      index = token.86 & 16777215;
      *error = 2;
      if (table != 6) goto <D.28987>; else goto <D.28988>;
      <D.28987>:
      if (table != 43) goto <D.28989>; else goto <D.28990>;
      <D.28989>:
      if (table != 10) goto <D.28991>; else goto <D.28992>;
      <D.28991>:
      *error = 1;
      D.28993 = 0B;
      return D.28993;
      <D.28992>:
      <D.28990>:
      <D.28988>:
      D.28994 = BIT_FIELD_REF <*image, 64, 192>;
      D.28995 = D.28994 & 34359738368;
      if (D.28995 != 0) goto <D.28996>; else goto <D.28997>;
      <D.28996>:
      if (table == 6) goto <D.28998>; else goto <D.28999>;
      <D.28998>:
      D.28993 = mono_lookup_dynamic_token_class (image, token, 0, 0B, 0B);
      return D.28993;
      <D.28999>:
      if (table == 10) goto <D.29000>; else goto <D.29001>;
      <D.29000>:
      D.29002 = mono_memberref_is_method (image, token);
      if (D.29002 == 0) goto <D.29003>; else goto <D.29004>;
      <D.29003>:
      *error = 1;
      D.28993 = 0B;
      return D.28993;
      <D.29004>:
      <D.29001>:
      init_generic_context_from_args (&context, type_args, method_args);
      D.28993 = mono_lookup_dynamic_token_class (image, token, 0, 0B, &context);
      return D.28993;
      <D.28997>:
      if (index <= 0) goto <D.29005>; else goto <D.29007>;
      <D.29007>:
      D.29008 = image->tables[table].rows;
      D.29009 = (int) D.29008;
      if (D.29009 < index) goto <D.29005>; else goto <D.29006>;
      <D.29005>:
      *error = 0;
      D.28993 = 0B;
      return D.28993;
      <D.29006>:
      if (table == 10) goto <D.29010>; else goto <D.29011>;
      <D.29010>:
      D.29012 = mono_memberref_is_method (image, token);
      if (D.29012 == 0) goto <D.29013>; else goto <D.29014>;
      <D.29013>:
      *error = 1;
      D.28993 = 0B;
      return D.28993;
      <D.29014>:
      <D.29011>:
      init_generic_context_from_args (&context, type_args, method_args);
      method = mono_get_method_full (image, token, 0B, &context);
      D.29015 = mono_loader_get_last_error ();
      if (D.29015 != 0B) goto <D.29016>; else goto <D.29017>;
      <D.29016>:
      D.29018 = mono_loader_get_last_error ();
      D.29019 = mono_loader_error_prepare_exception (D.29018);
      mono_raise_exception (D.29019);
      <D.29017>:
      D.28993 = method;
      return D.28993;
    }
  finally
    {
      context = {CLOBBER};
    }
}


mono_memberref_is_method (struct MonoImage * image, guint32 token)
{
  long unsigned int D.29022;
  long unsigned int D.29023;
  struct MonoTableInfo * D.29026;
  unsigned int D.29027;
  unsigned int D.29028;
  int D.29029;
  unsigned int D.29030;
  const char * sig.87;
  const char * sig.88;
  gboolean D.29033;
  char D.29034;
  _Bool D.29035;
  void * D.29036;
  struct MonoClass * D.29039;
  struct MonoClass * handle_class.89;
  _Bool D.29041;

  D.29022 = BIT_FIELD_REF <*image, 64, 192>;
  D.29023 = D.29022 & 34359738368;
  if (D.29023 == 0) goto <D.29024>; else goto <D.29025>;
  <D.29024>:
  {
    guint32 cols[3];
    const char * sig;

    try
      {
        D.29026 = &image->tables[10];
        D.29027 = token & 16777215;
        D.29028 = D.29027 + 4294967295;
        D.29029 = (int) D.29028;
        mono_metadata_decode_row (D.29026, D.29029, &cols, 3);
        D.29030 = cols[2];
        sig.87 = mono_metadata_blob_heap (image, D.29030);
        sig = sig.87;
        sig.88 = sig;
        mono_metadata_decode_blob_size (sig.88, &sig);
        sig.88 = sig;
        D.29034 = *sig.88;
        D.29035 = D.29034 != 6;
        D.29033 = (gboolean) D.29035;
        return D.29033;
      }
    finally
      {
        cols = {CLOBBER};
        sig = {CLOBBER};
      }
  }
  <D.29025>:
  {
    struct MonoClass * handle_class;

    try
      {
        D.29036 = mono_lookup_dynamic_token_class (image, token, 0, &handle_class, 0B);
        if (D.29036 == 0B) goto <D.29037>; else goto <D.29038>;
        <D.29037>:
        D.29033 = 0;
        return D.29033;
        <D.29038>:
        D.29039 = mono_defaults.methodhandle_class;
        handle_class.89 = handle_class;
        D.29041 = D.29039 == handle_class.89;
        D.29033 = (gboolean) D.29041;
        return D.29033;
      }
    finally
      {
        handle_class = {CLOBBER};
      }
  }
}


ves_icall_System_Reflection_Module_ResolveMemberToken (struct MonoImage * image, guint32 token, struct MonoArray * type_args, struct MonoArray * method_args, MonoResolveTokenError * error)
{
  unsigned int D.29045;
  struct MonoObject * D.29048;
  struct MonoDomain * D.29049;
  struct MonoDomain * D.29052;
  struct MonoClass * D.29053;
  struct MonoDomain * D.29056;
  struct MonoClass * D.29057;
  int D.29058;
  struct MonoDomain * D.29063;
  struct MonoClass * D.29064;
  struct MonoDomain * D.29067;
  struct MonoClass * D.29068;
  int table;

  D.29045 = token >> 24;
  table = (int) D.29045;
  *error = 2;
  switch (table) <default: <D.23547>, case 1: <D.23536>, case 2: <D.23535>, case 4: <D.23542>, case 6: <D.23539>, case 10: <D.23544>, case 27: <D.23537>, case 43: <D.23540>>
  <D.23535>:
  <D.23536>:
  <D.23537>:
  {
    struct MonoType * t;

    t = ves_icall_System_Reflection_Module_ResolveTypeToken (image, token, type_args, method_args, error);
    if (t != 0B) goto <D.29046>; else goto <D.29047>;
    <D.29046>:
    D.29049 = mono_domain_get ();
    D.29048 = mono_type_get_object (D.29049, t);
    return D.29048;
    <D.29047>:
    D.29048 = 0B;
    return D.29048;
  }
  <D.23539>:
  <D.23540>:
  {
    struct MonoMethod * m;

    m = ves_icall_System_Reflection_Module_ResolveMethodToken (image, token, type_args, method_args, error);
    if (m != 0B) goto <D.29050>; else goto <D.29051>;
    <D.29050>:
    D.29052 = mono_domain_get ();
    D.29053 = m->klass;
    D.29048 = mono_method_get_object (D.29052, m, D.29053);
    return D.29048;
    <D.29051>:
    D.29048 = 0B;
    return D.29048;
  }
  <D.23542>:
  {
    struct MonoClassField * f;

    f = ves_icall_System_Reflection_Module_ResolveFieldToken (image, token, type_args, method_args, error);
    if (f != 0B) goto <D.29054>; else goto <D.29055>;
    <D.29054>:
    D.29056 = mono_domain_get ();
    D.29057 = f->parent;
    D.29048 = mono_field_get_object (D.29056, D.29057, f);
    return D.29048;
    <D.29055>:
    D.29048 = 0B;
    return D.29048;
  }
  <D.23544>:
  D.29058 = mono_memberref_is_method (image, token);
  if (D.29058 != 0) goto <D.29059>; else goto <D.29060>;
  <D.29059>:
  {
    struct MonoMethod * m;

    m = ves_icall_System_Reflection_Module_ResolveMethodToken (image, token, type_args, method_args, error);
    if (m != 0B) goto <D.29061>; else goto <D.29062>;
    <D.29061>:
    D.29063 = mono_domain_get ();
    D.29064 = m->klass;
    D.29048 = mono_method_get_object (D.29063, m, D.29064);
    return D.29048;
    <D.29062>:
    D.29048 = 0B;
    return D.29048;
  }
  <D.29060>:
  {
    struct MonoClassField * f;

    f = ves_icall_System_Reflection_Module_ResolveFieldToken (image, token, type_args, method_args, error);
    if (f != 0B) goto <D.29065>; else goto <D.29066>;
    <D.29065>:
    D.29067 = mono_domain_get ();
    D.29068 = f->parent;
    D.29048 = mono_field_get_object (D.29067, D.29068, f);
    return D.29048;
    <D.29066>:
    D.29048 = 0B;
    return D.29048;
  }
  <D.23547>:
  *error = 1;
  D.29048 = 0B;
  return D.29048;
}


ves_icall_System_Reflection_Module_ResolveFieldToken (struct MonoImage * image, guint32 token, struct MonoArray * type_args, struct MonoArray * method_args, MonoResolveTokenError * error)
{
  unsigned int D.29070;
  int token.90;
  struct MonoClassField * D.29076;
  long unsigned int D.29077;
  long unsigned int D.29078;
  int D.29083;
  <unnamed-unsigned:24> D.29089;
  int D.29090;
  int D.29093;
  struct MonoLoaderError * D.29096;
  struct MonoLoaderError * D.29099;
  struct MonoException * D.29100;
  struct MonoClass * klass;
  int table;
  int index;
  struct MonoGenericContext context;
  struct MonoClassField * field;

  try
    {
      D.29070 = token >> 24;
      table = (int) D.29070;
      token.90 = (int) token;
      index = token.90 & 16777215;
      *error = 2;
      if (table != 4) goto <D.29072>; else goto <D.29073>;
      <D.29072>:
      if (table != 10) goto <D.29074>; else goto <D.29075>;
      <D.29074>:
      *error = 1;
      D.29076 = 0B;
      return D.29076;
      <D.29075>:
      <D.29073>:
      D.29077 = BIT_FIELD_REF <*image, 64, 192>;
      D.29078 = D.29077 & 34359738368;
      if (D.29078 != 0) goto <D.29079>; else goto <D.29080>;
      <D.29079>:
      if (table == 4) goto <D.29081>; else goto <D.29082>;
      <D.29081>:
      D.29076 = mono_lookup_dynamic_token_class (image, token, 0, 0B, 0B);
      return D.29076;
      <D.29082>:
      D.29083 = mono_memberref_is_method (image, token);
      if (D.29083 != 0) goto <D.29084>; else goto <D.29085>;
      <D.29084>:
      *error = 1;
      D.29076 = 0B;
      return D.29076;
      <D.29085>:
      init_generic_context_from_args (&context, type_args, method_args);
      D.29076 = mono_lookup_dynamic_token_class (image, token, 0, 0B, &context);
      return D.29076;
      <D.29080>:
      if (index <= 0) goto <D.29086>; else goto <D.29088>;
      <D.29088>:
      D.29089 = image->tables[table].rows;
      D.29090 = (int) D.29089;
      if (D.29090 < index) goto <D.29086>; else goto <D.29087>;
      <D.29086>:
      *error = 0;
      D.29076 = 0B;
      return D.29076;
      <D.29087>:
      if (table == 10) goto <D.29091>; else goto <D.29092>;
      <D.29091>:
      D.29093 = mono_memberref_is_method (image, token);
      if (D.29093 != 0) goto <D.29094>; else goto <D.29095>;
      <D.29094>:
      *error = 1;
      D.29076 = 0B;
      return D.29076;
      <D.29095>:
      <D.29092>:
      init_generic_context_from_args (&context, type_args, method_args);
      field = mono_field_from_token (image, token, &klass, &context);
      D.29096 = mono_loader_get_last_error ();
      if (D.29096 != 0B) goto <D.29097>; else goto <D.29098>;
      <D.29097>:
      D.29099 = mono_loader_get_last_error ();
      D.29100 = mono_loader_error_prepare_exception (D.29099);
      mono_raise_exception (D.29100);
      <D.29098>:
      D.29076 = field;
      return D.29076;
    }
  finally
    {
      klass = {CLOBBER};
      context = {CLOBBER};
    }
}


ves_icall_System_Reflection_Module_InternalGetTypes (struct MonoReflectionModule * module)
{
  struct MonoImage * D.29103;
  struct MonoArray * D.29106;
  struct MonoVTable * D.29107;
  struct MonoDomain * D.29108;
  struct MonoClass * D.29109;
  struct MonoArray * exceptions.91;
  long unsigned int D.29111;
  char * D.29112;
  long unsigned int D.29115;
  struct MonoArray * exceptions;
  int i;

  try
    {
      D.29103 = module->image;
      if (D.29103 == 0B) goto <D.29104>; else goto <D.29105>;
      <D.29104>:
      D.29107 = MEM[(struct MonoObject *)module].vtable;
      D.29108 = D.29107->domain;
      D.29109 = mono_defaults.monotype_class;
      D.29106 = mono_array_new (D.29108, D.29109, 0);
      return D.29106;
      <D.29105>:
      {
        struct MonoArray * res;

        D.29107 = MEM[(struct MonoObject *)module].vtable;
        D.29108 = D.29107->domain;
        D.29103 = module->image;
        res = mono_module_get_types (D.29108, D.29103, &exceptions, 0);
        i = 0;
        goto <D.23473>;
        <D.23472>:
        {
          struct MonoException * ex;

          exceptions.91 = exceptions;
          D.29111 = (long unsigned int) i;
          D.29112 = mono_array_addr_with_size (exceptions.91, 8, D.29111);
          ex = MEM[(struct MonoException * *)D.29112];
          if (ex != 0B) goto <D.29113>; else goto <D.29114>;
          <D.29113>:
          mono_raise_exception (ex);
          <D.29114>:
        }
        i = i + 1;
        <D.23473>:
        D.29111 = (long unsigned int) i;
        exceptions.91 = exceptions;
        D.29115 = mono_array_length (exceptions.91);
        if (D.29111 < D.29115) goto <D.23472>; else goto <D.23474>;
        <D.23474>:
        D.29106 = res;
        return D.29106;
      }
    }
  finally
    {
      exceptions = {CLOBBER};
    }
}


mono_module_get_types (struct MonoDomain * domain, struct MonoImage * image, struct MonoArray * * exceptions, MonoBoolean exportedOnly)
{
  unsigned int D.29120;
  <unnamed-unsigned:24> D.29123;
  int D.29124;
  struct MonoClass * D.29126;
  long unsigned int D.29127;
  struct MonoClass * D.29128;
  struct MonoArray * D.29129;
  int D.29133;
  int D.29134;
  unsigned int D.29135;
  struct MonoType * D.29138;
  struct MonoReflectionType * D.29139;
  _Bool D.29141;
  long int D.29142;
  long int D.29143;
  struct MonoArray * D.29146;
  struct MonoLoaderError * D.29147;
  struct MonoArray * D.29150;
  struct MonoArray * res;
  struct MonoClass * klass;
  struct MonoTableInfo * tdef;
  int i;
  int count;
  guint32 attrs;
  guint32 visibility;

  tdef = &image->tables[2];
  if (exportedOnly != 0) goto <D.29118>; else goto <D.29119>;
  <D.29118>:
  count = 0;
  i = 1;
  goto <D.23371>;
  <D.23370>:
  attrs = mono_metadata_decode_row_col (tdef, i, 0);
  visibility = attrs & 7;
  D.29120 = visibility + 4294967295;
  if (D.29120 <= 1) goto <D.29121>; else goto <D.29122>;
  <D.29121>:
  count = count + 1;
  <D.29122>:
  i = i + 1;
  <D.23371>:
  D.29123 = tdef->rows;
  D.29124 = (int) D.29123;
  if (D.29124 > i) goto <D.23370>; else goto <D.23372>;
  <D.23372>:
  goto <D.29125>;
  <D.29119>:
  D.29123 = tdef->rows;
  D.29124 = (int) D.29123;
  count = D.29124 + -1;
  <D.29125>:
  D.29126 = mono_defaults.monotype_class;
  D.29127 = (long unsigned int) count;
  res = mono_array_new (domain, D.29126, D.29127);
  D.29128 = mono_defaults.exception_class;
  D.29127 = (long unsigned int) count;
  D.29129 = mono_array_new (domain, D.29128, D.29127);
  *exceptions = D.29129;
  count = 0;
  i = 1;
  goto <D.23378>;
  <D.23377>:
  attrs = mono_metadata_decode_row_col (tdef, i, 0);
  visibility = attrs & 7;
  if (exportedOnly == 0) goto <D.29130>; else goto <D.29132>;
  <D.29132>:
  D.29120 = visibility + 4294967295;
  if (D.29120 <= 1) goto <D.29130>; else goto <D.29131>;
  <D.29130>:
  D.29133 = i + 1;
  D.29134 = D.29133 | 33554432;
  D.29135 = (unsigned int) D.29134;
  klass = mono_class_get (image, D.29135);
  if (klass != 0B) goto <D.29136>; else goto <D.29137>;
  <D.29136>:
  {
    void * * __p;

    D.29127 = (long unsigned int) count;
    __p = mono_array_addr_with_size (res, 8, D.29127);
    D.29138 = &klass->byval_arg;
    D.29139 = mono_type_get_object (domain, D.29138);
    mono_gc_wbarrier_set_arrayref (res, __p, D.29139);
  }
  goto <D.29140>;
  <D.29137>:
  {
    struct MonoLoaderError * error;
    struct MonoException * ex;

    error = mono_loader_get_last_error ();
    D.29141 = error == 0B;
    D.29142 = (long int) D.29141;
    D.29143 = __builtin_expect (D.29142, 0);
    if (D.29143 != 0) goto <D.29144>; else goto <D.29145>;
    <D.29144>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "icall.c", 5142, "error != NULL");
    <D.29145>:
    ex = mono_loader_error_prepare_exception (error);
    {
      void * * __p;

      D.29146 = *exceptions;
      D.29127 = (long unsigned int) count;
      __p = mono_array_addr_with_size (D.29146, 8, D.29127);
      D.29146 = *exceptions;
      mono_gc_wbarrier_set_arrayref (D.29146, __p, ex);
    }
  }
  <D.29140>:
  D.29147 = mono_loader_get_last_error ();
  if (D.29147 != 0B) goto <D.29148>; else goto <D.29149>;
  <D.29148>:
  mono_loader_clear_error ();
  <D.29149>:
  count = count + 1;
  <D.29131>:
  i = i + 1;
  <D.23378>:
  D.29123 = tdef->rows;
  D.29124 = (int) D.29123;
  if (D.29124 > i) goto <D.23377>; else goto <D.23379>;
  <D.23379>:
  D.29150 = res;
  return D.29150;
}


ves_icall_System_Reflection_Module_GetPEKind (struct MonoImage * image, gint32 * pe_kind, gint32 * machine)
{
  long unsigned int D.29152;
  long unsigned int D.29153;
  unsigned int D.29156;
  int D.29157;
  unsigned int D.29158;
  int D.29159;
  void * D.29161;
  unsigned int D.29162;
  int D.29163;
  int D.29164;
  short unsigned int D.29165;
  int D.29166;

  D.29152 = BIT_FIELD_REF <*image, 64, 192>;
  D.29153 = D.29152 & 34359738368;
  if (D.29153 != 0) goto <D.29154>; else goto <D.29155>;
  <D.29154>:
  {
    struct MonoDynamicImage * dyn;

    dyn = image;
    D.29156 = dyn->pe_kind;
    D.29157 = (int) D.29156;
    *pe_kind = D.29157;
    D.29158 = dyn->machine;
    D.29159 = (int) D.29158;
    *machine = D.29159;
  }
  goto <D.29160>;
  <D.29155>:
  D.29161 = image->image_info;
  D.29162 = MEM[(struct MonoCLIImageInfo *)D.29161].cli_cli_header.ch_flags;
  D.29163 = (int) D.29162;
  D.29164 = D.29163 & 3;
  *pe_kind = D.29164;
  D.29161 = image->image_info;
  D.29165 = MEM[(struct MonoCLIImageInfo *)D.29161].cli_header.coff.coff_machine;
  D.29166 = (int) D.29165;
  *machine = D.29166;
  <D.29160>:
}


ves_icall_System_Reflection_Module_GetMDStreamVersion (struct MonoImage * image)
{
  gint32 D.29167;
  short int D.29168;
  int D.29169;
  int D.29170;
  short int D.29171;
  int D.29172;

  D.29168 = image->md_version_major;
  D.29169 = (int) D.29168;
  D.29170 = D.29169 << 16;
  D.29171 = image->md_version_minor;
  D.29172 = (int) D.29171;
  D.29167 = D.29170 | D.29172;
  return D.29167;
}


ves_icall_System_Reflection_Module_GetHINSTANCE (struct MonoReflectionModule * module)
{
  void * D.29174;

  D.29174 = -1B;
  return D.29174;
}


ves_icall_System_Reflection_Module_GetGuidInternal (struct MonoReflectionModule * module)
{
  struct MonoVTable * D.29176;
  struct MonoImage * D.29177;
  _Bool D.29178;
  long int D.29179;
  long int D.29180;
  struct MonoString * D.29183;
  char * D.29184;
  struct MonoDomain * domain;

  D.29176 = MEM[(struct MonoObject *)module].vtable;
  domain = D.29176->domain;
  D.29177 = module->image;
  D.29178 = D.29177 == 0B;
  D.29179 = (long int) D.29178;
  D.29180 = __builtin_expect (D.29179, 0);
  if (D.29180 != 0) goto <D.29181>; else goto <D.29182>;
  <D.29181>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "icall.c", 5323, "module->image");
  <D.29182>:
  D.29177 = module->image;
  D.29184 = D.29177->guid;
  D.29183 = mono_string_new (domain, D.29184);
  return D.29183;
}


ves_icall_System_Reflection_Module_GetGlobalType (struct MonoReflectionModule * module)
{
  struct MonoVTable * D.29186;
  struct MonoImage * D.29187;
  _Bool D.29188;
  long int D.29189;
  long int D.29190;
  long unsigned int D.29193;
  long unsigned int D.29194;
  int D.29197;
  struct MonoReflectionType * D.29200;
  struct MonoType * D.29201;
  struct MonoDomain * domain;
  struct MonoClass * klass;

  D.29186 = MEM[(struct MonoObject *)module].vtable;
  domain = D.29186->domain;
  D.29187 = module->image;
  D.29188 = D.29187 == 0B;
  D.29189 = (long int) D.29188;
  D.29190 = __builtin_expect (D.29189, 0);
  if (D.29190 != 0) goto <D.29191>; else goto <D.29192>;
  <D.29191>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "icall.c", 5299, "module->image");
  <D.29192>:
  D.29187 = module->image;
  D.29193 = BIT_FIELD_REF <*D.29187, 64, 192>;
  D.29194 = D.29193 & 34359738368;
  if (D.29194 != 0) goto <D.29195>; else goto <D.29196>;
  <D.29195>:
  D.29187 = module->image;
  D.29197 = MEM[(struct MonoDynamicImage *)D.29187].initial_image;
  if (D.29197 != 0) goto <D.29198>; else goto <D.29199>;
  <D.29198>:
  D.29200 = 0B;
  return D.29200;
  <D.29199>:
  <D.29196>:
  D.29187 = module->image;
  klass = mono_class_get (D.29187, 33554433);
  D.29201 = &klass->byval_arg;
  D.29200 = mono_type_get_object (domain, D.29201);
  return D.29200;
}


ves_icall_System_Reflection_Module_Close (struct MonoReflectionModule * module)
{

}


ves_icall_System_Reflection_MethodBase_GetMethodFromHandleInternalType (struct MonoMethod * method, struct MonoType * type)
{
  struct MonoClass * D.29205;
  struct MonoClass * D.29206;
  struct MonoClass * D.29207;
  struct MonoReflectionMethod * D.29210;
  struct MonoDomain * D.29216;
  struct MonoClass * klass;

  if (type != 0B) goto <D.29203>; else goto <D.29204>;
  <D.29203>:
  klass = mono_class_from_mono_type (type);
  D.29205 = method->klass;
  D.29206 = mono_class_get_generic_type_definition (D.29205);
  D.29207 = mono_class_get_generic_type_definition (klass);
  if (D.29206 != D.29207) goto <D.29208>; else goto <D.29209>;
  <D.29208>:
  D.29210 = 0B;
  return D.29210;
  <D.29209>:
  D.29205 = method->klass;
  if (D.29205 != klass) goto <D.29211>; else goto <D.29212>;
  <D.29211>:
  method = mono_method_get_equivalent_method (method, klass);
  if (method == 0B) goto <D.29213>; else goto <D.29214>;
  <D.29213>:
  D.29210 = 0B;
  return D.29210;
  <D.29214>:
  <D.29212>:
  goto <D.29215>;
  <D.29204>:
  klass = method->klass;
  <D.29215>:
  D.29216 = mono_domain_get ();
  D.29210 = mono_method_get_object (D.29216, method, klass);
  return D.29210;
}


mono_method_get_equivalent_method (struct MonoMethod * method, struct MonoClass * klass)
{
  long unsigned int D.29218;
  long unsigned int D.29219;
  struct MonoGenericInst * D.29222;
  struct MonoGenericInst * D.29225;
  struct MonoGenericInst * D.29226;
  struct MonoGenericClass * D.29227;
  struct MonoGenericInst * D.29230;
  struct MonoGenericContainer * D.29232;
  struct MonoGenericInst * D.29235;
  struct MonoMethod * D.29236;
  struct MonoMethod * D.29237;
  struct MonoClass * D.29238;
  unsigned char D.29239;
  struct MonoMethod * * D.29242;
  long unsigned int D.29243;
  long unsigned int D.29244;
  struct MonoMethod * * D.29245;
  struct MonoMethod * D.29246;
  unsigned int i.92;
  unsigned int D.29250;
  unsigned char D.29251;
  int iftmp.93;
  unsigned int offset.94;
  unsigned int D.29260;
  _Bool D.29261;
  long int D.29262;
  long int D.29263;
  struct MonoMethod * * D.29266;
  long unsigned int D.29267;
  long unsigned int D.29268;
  struct MonoMethod * * D.29269;
  int offset;
  int i;

  offset = -1;
  D.29218 = BIT_FIELD_REF <*method, 64, 256>;
  D.29219 = D.29218 & 4096;
  if (D.29219 != 0) goto <D.29220>; else goto <D.29221>;
  <D.29220>:
  D.29222 = MEM[(struct MonoMethodInflated *)method].context.method_inst;
  if (D.29222 != 0B) goto <D.29223>; else goto <D.29224>;
  <D.29223>:
  {
    struct MonoMethodInflated * inflated;
    struct MonoGenericContext ctx;

    try
      {
        inflated = method;
        D.29225 = inflated->context.method_inst;
        ctx.method_inst = D.29225;
        D.29226 = inflated->context.class_inst;
        ctx.class_inst = D.29226;
        D.29227 = klass->generic_class;
        if (D.29227 != 0B) goto <D.29228>; else goto <D.29229>;
        <D.29228>:
        D.29227 = klass->generic_class;
        D.29230 = D.29227->context.class_inst;
        ctx.class_inst = D.29230;
        goto <D.29231>;
        <D.29229>:
        D.29232 = klass->generic_container;
        if (D.29232 != 0B) goto <D.29233>; else goto <D.29234>;
        <D.29233>:
        D.29232 = klass->generic_container;
        D.29235 = D.29232->context.class_inst;
        ctx.class_inst = D.29235;
        <D.29234>:
        <D.29231>:
        D.29237 = inflated->declaring;
        D.29236 = mono_class_inflate_generic_method_full (D.29237, klass, &ctx);
        return D.29236;
      }
    finally
      {
        ctx = {CLOBBER};
      }
  }
  <D.29224>:
  <D.29221>:
  D.29238 = method->klass;
  mono_class_setup_methods (D.29238);
  D.29238 = method->klass;
  D.29239 = D.29238->exception_type;
  if (D.29239 != 0) goto <D.29240>; else goto <D.29241>;
  <D.29240>:
  D.29236 = 0B;
  return D.29236;
  <D.29241>:
  i = 0;
  goto <D.23260>;
  <D.23259>:
  D.29238 = method->klass;
  D.29242 = D.29238->methods;
  D.29243 = (long unsigned int) i;
  D.29244 = D.29243 * 8;
  D.29245 = D.29242 + D.29244;
  D.29246 = *D.29245;
  if (D.29246 == method) goto <D.29247>; else goto <D.29248>;
  <D.29247>:
  offset = i;
  goto <D.23258>;
  <D.29248>:
  i = i + 1;
  <D.23260>:
  i.92 = (unsigned int) i;
  D.29238 = method->klass;
  D.29250 = D.29238->method.count;
  if (i.92 < D.29250) goto <D.23259>; else goto <D.23258>;
  <D.23258>:
  mono_class_setup_methods (klass);
  D.29251 = klass->exception_type;
  if (D.29251 != 0) goto <D.29252>; else goto <D.29253>;
  <D.29252>:
  D.29236 = 0B;
  return D.29236;
  <D.29253>:
  if (offset < 0) goto <D.29255>; else goto <D.29258>;
  <D.29258>:
  offset.94 = (unsigned int) offset;
  D.29260 = klass->method.count;
  if (offset.94 >= D.29260) goto <D.29255>; else goto <D.29256>;
  <D.29255>:
  iftmp.93 = 1;
  goto <D.29257>;
  <D.29256>:
  iftmp.93 = 0;
  <D.29257>:
  D.29261 = iftmp.93 != 0;
  D.29262 = (long int) D.29261;
  D.29263 = __builtin_expect (D.29262, 0);
  if (D.29263 != 0) goto <D.29264>; else goto <D.29265>;
  <D.29264>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "icall.c", 4779, "offset >= 0 && offset < klass->method.count");
  <D.29265>:
  D.29266 = klass->methods;
  D.29267 = (long unsigned int) offset;
  D.29268 = D.29267 * 8;
  D.29269 = D.29266 + D.29268;
  D.29236 = *D.29269;
  return D.29236;
}


ves_icall_System_Reflection_MethodBase_GetMethodFromHandleInternal (struct MonoMethod * method)
{
  struct MonoReflectionMethod * D.29272;
  struct MonoDomain * D.29273;

  D.29273 = mono_domain_get ();
  D.29272 = mono_method_get_object (D.29273, method, 0B);
  return D.29272;
}


ves_icall_System_Reflection_MethodBase_GetMethodBodyInternal (struct MonoMethod * method)
{
  struct MonoReflectionMethodBody * D.29275;
  struct MonoDomain * D.29276;

  D.29276 = mono_domain_get ();
  D.29275 = mono_method_body_get_object (D.29276, method);
  return D.29275;
}


ves_icall_GetCurrentMethod ()
{
  long unsigned int D.29278;
  long unsigned int D.29279;
  struct MonoReflectionMethod * D.29280;
  struct MonoDomain * D.29281;
  struct MonoMethod * m;

  m = mono_method_get_last_managed ();
  goto <D.23248>;
  <D.23247>:
  m = MEM[(struct MonoMethodInflated *)m].declaring;
  <D.23248>:
  D.29278 = BIT_FIELD_REF <*m, 64, 256>;
  D.29279 = D.29278 & 4096;
  if (D.29279 != 0) goto <D.23247>; else goto <D.23249>;
  <D.23249>:
  D.29281 = mono_domain_get ();
  D.29280 = mono_method_get_object (D.29281, m, 0B);
  return D.29280;
}


ves_icall_System_Reflection_FieldInfo_internal_from_handle_type (struct MonoClassField * handle, struct MonoType * type)
{
  _Bool D.29283;
  long int D.29284;
  long int D.29285;
  struct MonoClass * D.29291;
  struct MonoReflectionField * D.29296;
  struct MonoDomain * D.29297;
  gboolean found;
  struct MonoClass * klass;
  struct MonoClass * k;

  found = 0;
  D.29283 = handle == 0B;
  D.29284 = (long int) D.29283;
  D.29285 = __builtin_expect (D.29284, 0);
  if (D.29285 != 0) goto <D.29286>; else goto <D.29287>;
  <D.29286>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "icall.c", 1637, "handle");
  <D.29287>:
  if (type == 0B) goto <D.29288>; else goto <D.29289>;
  <D.29288>:
  klass = handle->parent;
  goto <D.29290>;
  <D.29289>:
  klass = mono_class_from_mono_type (type);
  k = klass;
  goto <D.21937>;
  <D.21936>:
  D.29291 = handle->parent;
  if (D.29291 == k) goto <D.29292>; else goto <D.29293>;
  <D.29292>:
  found = 1;
  goto <D.21935>;
  <D.29293>:
  k = k->parent;
  <D.21937>:
  if (k != 0B) goto <D.21936>; else goto <D.21935>;
  <D.21935>:
  if (found == 0) goto <D.29294>; else goto <D.29295>;
  <D.29294>:
  D.29296 = 0B;
  return D.29296;
  <D.29295>:
  <D.29290>:
  D.29297 = mono_domain_get ();
  D.29296 = mono_field_get_object (D.29297, klass, handle);
  return D.29296;
}


ves_icall_System_Reflection_FieldInfo_get_marshal_info (struct MonoReflectionField * field)
{
  struct MonoClassField * D.29299;
  struct MonoGenericContainer * D.29302;
  struct MonoGenericClass * D.29304;
  struct MonoGenericInst * D.29306;
  long unsigned int D.29307;
  long unsigned int D.29308;
  struct MonoReflectionMarshalAsAttribute * D.29309;
  struct MonoClassField * D.29310;
  struct MonoMarshalSpec * D.29313;
  struct MonoVTable * D.29316;
  struct MonoDomain * D.29317;
  unsigned int i.95;
  unsigned int D.29319;
  struct MonoClass * klass;
  struct MonoMarshalType * info;
  int i;

  D.29299 = field->field;
  klass = D.29299->parent;
  D.29302 = klass->generic_container;
  if (D.29302 != 0B) goto <D.29300>; else goto <D.29303>;
  <D.29303>:
  D.29304 = klass->generic_class;
  if (D.29304 != 0B) goto <D.29305>; else goto <D.29301>;
  <D.29305>:
  D.29304 = klass->generic_class;
  D.29306 = D.29304->context.class_inst;
  D.29307 = BIT_FIELD_REF <*D.29306, 64, 0>;
  D.29308 = D.29307 & 18014398509481984;
  if (D.29308 != 0) goto <D.29300>; else goto <D.29301>;
  <D.29300>:
  D.29309 = 0B;
  return D.29309;
  <D.29301>:
  info = mono_marshal_load_type_info (klass);
  i = 0;
  goto <D.21926>;
  <D.21925>:
  D.29310 = info->fields[i].field;
  D.29299 = field->field;
  if (D.29310 == D.29299) goto <D.29311>; else goto <D.29312>;
  <D.29311>:
  D.29313 = info->fields[i].mspec;
  if (D.29313 == 0B) goto <D.29314>; else goto <D.29315>;
  <D.29314>:
  D.29309 = 0B;
  return D.29309;
  <D.29315>:
  D.29316 = field->object.vtable;
  D.29317 = D.29316->domain;
  D.29313 = info->fields[i].mspec;
  D.29309 = mono_reflection_marshal_as_attribute_from_marshal_spec (D.29317, klass, D.29313);
  return D.29309;
  <D.29312>:
  i = i + 1;
  <D.21926>:
  i.95 = (unsigned int) i;
  D.29319 = info->num_fields;
  if (i.95 < D.29319) goto <D.21925>; else goto <D.21927>;
  <D.21927>:
  D.29309 = 0B;
  return D.29309;
}


ves_icall_System_Reflection_FieldInfo_GetTypeModifiers (struct MonoReflectionField * field, MonoBoolean optional)
{
  struct MonoClassField * D.29321;
  int D.29322;
  struct MonoArray * D.29325;
  struct MonoClass * D.29326;
  struct MonoImage * D.29327;
  int D.29328;
  struct MonoError error;
  struct MonoType * type;

  try
    {
      D.29321 = field->field;
      type = mono_field_get_type_checked (D.29321, &error);
      D.29322 = mono_error_ok (&error);
      if (D.29322 == 0) goto <D.29323>; else goto <D.29324>;
      <D.29323>:
      mono_error_raise_exception (&error);
      <D.29324>:
      D.29321 = field->field;
      D.29326 = D.29321->parent;
      D.29327 = D.29326->image;
      D.29328 = (int) optional;
      D.29325 = type_array_from_modifiers (D.29327, type, D.29328);
      return D.29325;
    }
  finally
    {
      error = {CLOBBER};
    }
}


ves_icall_TypeBuilder_get_IsGenericParameter (struct MonoReflectionTypeBuilder * tb)
{
  MonoBoolean D.29331;
  struct MonoType * D.29332;

  D.29332 = tb->type.type;
  D.29331 = is_generic_parameter (D.29332);
  return D.29331;
}


ves_icall_ModuleBuilder_getToken (struct MonoReflectionModuleBuilder * mb, struct MonoObject * obj, gboolean create_open_instance)
{
  _Bool D.29334;
  long int D.29335;
  long int D.29336;
  gint32 D.29341;
  struct MonoDynamicImage * D.29342;
  unsigned int D.29343;

  D.29334 = obj == 0B;
  D.29335 = (long int) D.29334;
  D.29336 = __builtin_expect (D.29335, 0);
  if (D.29336 != 0) goto <D.29337>; else goto <D.29338>;
  <D.29337>:
  {
    struct MonoException * ex;

    if (obj != 0B) goto <D.29339>; else goto <D.29340>;
    <D.29339>:
    <D.29340>:
    ex = mono_get_exception_argument_null ("obj");
    mono_raise_exception (ex);
  }
  <D.29338>:
  D.29342 = mb->dynamic_image;
  D.29343 = mono_image_create_token (D.29342, obj, create_open_instance, 1);
  D.29341 = (gint32) D.29343;
  return D.29341;
}


ves_icall_ModuleBuilder_getMethodToken (struct MonoReflectionModuleBuilder * mb, struct MonoReflectionMethod * method, struct MonoArray * opt_param_types)
{
  _Bool D.29345;
  long int D.29346;
  long int D.29347;
  gint32 D.29352;
  struct MonoDynamicImage * D.29353;
  unsigned int D.29354;

  D.29345 = method == 0B;
  D.29346 = (long int) D.29345;
  D.29347 = __builtin_expect (D.29346, 0);
  if (D.29347 != 0) goto <D.29348>; else goto <D.29349>;
  <D.29348>:
  {
    struct MonoException * ex;

    if (method != 0B) goto <D.29350>; else goto <D.29351>;
    <D.29350>:
    <D.29351>:
    ex = mono_get_exception_argument_null ("method");
    mono_raise_exception (ex);
  }
  <D.29349>:
  D.29353 = mb->dynamic_image;
  D.29354 = mono_image_create_method_token (D.29353, method, opt_param_types);
  D.29352 = (gint32) D.29354;
  return D.29352;
}


ves_icall_ModuleBuilder_create_modified_type (struct MonoReflectionTypeBuilder * tb, struct MonoString * smodifiers)
{
  struct MonoType * D.29356;
  char D.29357;
  int D.29358;
  struct MonoReflectionType * D.29361;
  struct MonoVTable * D.29362;
  struct MonoDomain * D.29363;
  struct MonoType * D.29364;
  struct MonoType * D.29365;
  unsigned int rank.96;
  struct MonoClass * klass;
  int isbyref;
  int rank;
  char * str;
  char * p;

  isbyref = 0;
  str = mono_string_to_utf8 (smodifiers);
  D.29356 = tb->type.type;
  klass = mono_class_from_mono_type (D.29356);
  p = str;
  goto <D.23578>;
  <D.23577>:
  D.29357 = *p;
  D.29358 = (int) D.29357;
  switch (D.29358) <default: <D.23576>, case 38: <D.23569>, case 42: <D.23570>, case 91: <D.23572>>
  <D.23569>:
  if (isbyref != 0) goto <D.29359>; else goto <D.29360>;
  <D.29359>:
  monoeg_g_free (str);
  D.29361 = 0B;
  return D.29361;
  <D.29360>:
  isbyref = 1;
  p = p + 1;
  monoeg_g_free (str);
  D.29362 = MEM[(struct MonoObject *)tb].vtable;
  D.29363 = D.29362->domain;
  D.29364 = &klass->this_arg;
  D.29361 = mono_type_get_object (D.29363, D.29364);
  return D.29361;
  <D.23570>:
  D.29365 = &klass->byval_arg;
  klass = mono_ptr_class_get (D.29365);
  mono_class_init (klass);
  p = p + 1;
  goto <D.23571>;
  <D.23572>:
  rank = 1;
  p = p + 1;
  goto <D.23575>;
  <D.23574>:
  D.29357 = *p;
  if (D.29357 == 93) goto <D.23573>; else goto <D.29366>;
  <D.29366>:
  D.29357 = *p;
  if (D.29357 == 44) goto <D.29367>; else goto <D.29368>;
  <D.29367>:
  rank = rank + 1;
  goto <D.29369>;
  <D.29368>:
  D.29357 = *p;
  if (D.29357 != 42) goto <D.29370>; else goto <D.29371>;
  <D.29370>:
  monoeg_g_free (str);
  D.29361 = 0B;
  return D.29361;
  <D.29371>:
  <D.29369>:
  p = p + 1;
  <D.23575>:
  D.29357 = *p;
  if (D.29357 != 0) goto <D.23574>; else goto <D.23573>;
  <D.23573>:
  D.29357 = *p;
  if (D.29357 != 93) goto <D.29372>; else goto <D.29373>;
  <D.29372>:
  monoeg_g_free (str);
  D.29361 = 0B;
  return D.29361;
  <D.29373>:
  p = p + 1;
  rank.96 = (unsigned int) rank;
  klass = mono_array_class_get (klass, rank.96);
  mono_class_init (klass);
  goto <D.23571>;
  <D.23576>:
  goto <D.23571>;
  <D.23571>:
  <D.23578>:
  D.29357 = *p;
  if (D.29357 != 0) goto <D.23577>; else goto <D.23579>;
  <D.23579>:
  monoeg_g_free (str);
  D.29362 = MEM[(struct MonoObject *)tb].vtable;
  D.29363 = D.29362->domain;
  D.29365 = &klass->byval_arg;
  D.29361 = mono_type_get_object (D.29363, D.29365);
  return D.29361;
}


ves_icall_ModuleBuilder_build_metadata (struct MonoReflectionModuleBuilder * mb)
{
  mono_image_build_metadata (mb);
}


ves_icall_ModuleBuilder_WriteToFile (struct MonoReflectionModuleBuilder * mb, void * file)
{
  mono_image_create_pefile (mb, file);
}


ves_icall_ModuleBuilder_RegisterToken (struct MonoReflectionModuleBuilder * mb, struct MonoObject * obj, guint32 token)
{
  struct MonoDynamicImage * D.29377;

  D.29377 = mb->dynamic_image;
  mono_image_register_token (D.29377, token, obj);
}


ves_icall_EnumBuilder_setup_enum_type (struct MonoReflectionType * enumtype, struct MonoReflectionType * t)
{
  struct MonoType * D.29378;

  D.29378 = t->type;
  enumtype->type = D.29378;
}


ves_icall_System_Reflection_AssemblyName_ParseName (struct MonoReflectionAssemblyName * name, struct MonoString * assname)
{
  struct MonoVTable * D.29379;
  int D.29380;
  const mono_byte * D.29383;
  gboolean D.29384;
  int is_version_defined.97;
  int is_token_defined.98;
  struct MonoAssemblyName aname;
  struct MonoDomain * domain;
  char * val;
  gboolean is_version_defined;
  gboolean is_token_defined;

  try
    {
      D.29379 = MEM[(struct MonoObject *)name].vtable;
      domain = D.29379->domain;
      aname.public_key = 0B;
      val = mono_string_to_utf8 (assname);
      D.29380 = mono_assembly_name_parse_full (val, &aname, 1, &is_version_defined, &is_token_defined);
      if (D.29380 == 0) goto <D.29381>; else goto <D.29382>;
      <D.29381>:
      D.29383 = aname.public_key;
      monoeg_g_free (D.29383);
      monoeg_g_free (val);
      D.29384 = 0;
      return D.29384;
      <D.29382>:
      is_version_defined.97 = is_version_defined;
      is_token_defined.98 = is_token_defined;
      fill_reflection_assembly_name (domain, name, &aname, "", is_version_defined.97, 0, is_token_defined.98);
      mono_assembly_name_free (&aname);
      D.29383 = aname.public_key;
      monoeg_g_free (D.29383);
      monoeg_g_free (val);
      D.29384 = 1;
      return D.29384;
    }
  finally
    {
      aname = {CLOBBER};
      is_version_defined = {CLOBBER};
      is_token_defined = {CLOBBER};
    }
}


fill_reflection_assembly_name (struct MonoDomain * domain, struct MonoReflectionAssemblyName * aname, struct MonoAssemblyName * name, const char * absolute, gboolean by_default_version, gboolean default_publickey, gboolean default_token)
{
  struct MonoString * * D.29389;
  const char * D.29390;
  struct MonoString * D.29391;
  short unsigned int D.29392;
  int D.29393;
  short unsigned int D.29394;
  int D.29395;
  short unsigned int D.29396;
  int D.29397;
  unsigned int D.29398;
  short unsigned int D.29399;
  int D.29400;
  unsigned int D.29401;
  short unsigned int D.29402;
  unsigned int D.29403;
  struct MonoObject * * D.29406;
  unsigned int D.29407;
  unsigned int D.29408;
  unsigned int D.29409;
  unsigned int D.29410;
  struct MonoObject * D.29411;
  char D.29414;
  struct MonoString * * D.29419;
  struct MonoString * D.29420;
  struct MonoMethod * create_culture.99;
  struct MonoImage * D.29424;
  struct MonoMethod * create_culture.100;
  _Bool D.29426;
  long int D.29427;
  long int D.29428;
  const char * D.29431;
  struct MonoString * D.29434;
  struct MonoObject * * D.29435;
  struct MonoObject * D.29436;
  const mono_byte * pkey_ptr.101;
  const char * pkey_ptr.102;
  struct MonoArray * * D.29441;
  struct MonoClass * D.29442;
  long unsigned int D.29443;
  struct MonoArray * D.29444;
  struct MonoArray * D.29445;
  char * D.29446;
  long unsigned int D.29447;
  unsigned int D.29448;
  unsigned int D.29449;
  struct MonoArray * D.29453;
  unsigned char D.29454;
  struct MonoArray * * D.29457;
  struct MonoArray * D.29458;
  struct MonoArray * D.29459;
  int j.103;
  unsigned char D.29461;
  int D.29462;
  char D.29463;
  char D.29464;
  int j.104;
  unsigned char D.29466;
  int D.29467;
  char D.29468;
  signed char D.29469;
  signed char D.29470;
  signed char D.29471;
  char D.29472;
  struct MonoArray * D.29476;
  static struct MonoMethod * create_culture = 0B;
  void * args[2];
  guint32 pkey_len;
  const char * pkey_ptr;
  gchar * codebase;
  MonoBoolean assembly_ref;

  try
    {
      assembly_ref = 0;
      D.29389 = &aname->name;
      D.29390 = name->name;
      D.29391 = mono_string_new (domain, D.29390);
      mono_gc_wbarrier_set_field (aname, D.29389, D.29391);
      D.29392 = name->major;
      D.29393 = (int) D.29392;
      aname->major = D.29393;
      D.29394 = name->minor;
      D.29395 = (int) D.29394;
      aname->minor = D.29395;
      D.29396 = name->build;
      D.29397 = (int) D.29396;
      aname->build = D.29397;
      D.29398 = name->flags;
      aname->flags = D.29398;
      D.29399 = name->revision;
      D.29400 = (int) D.29399;
      aname->revision = D.29400;
      D.29401 = name->hash_alg;
      aname->hashalg = D.29401;
      aname->versioncompat = 1;
      D.29402 = name->arch;
      D.29403 = (unsigned int) D.29402;
      aname->processor_architecture = D.29403;
      if (by_default_version != 0) goto <D.29404>; else goto <D.29405>;
      <D.29404>:
      D.29406 = &aname->version;
      D.29392 = name->major;
      D.29407 = (unsigned int) D.29392;
      D.29394 = name->minor;
      D.29408 = (unsigned int) D.29394;
      D.29396 = name->build;
      D.29409 = (unsigned int) D.29396;
      D.29399 = name->revision;
      D.29410 = (unsigned int) D.29399;
      D.29411 = create_version (domain, D.29407, D.29408, D.29409, D.29410);
      mono_gc_wbarrier_set_field (aname, D.29406, D.29411);
      <D.29405>:
      codebase = 0B;
      if (absolute != 0B) goto <D.29412>; else goto <D.29413>;
      <D.29412>:
      D.29414 = *absolute;
      if (D.29414 != 0) goto <D.29415>; else goto <D.29416>;
      <D.29415>:
      {
        const gchar * prepend;
        gchar * result;

        prepend = "file://";
        codebase = monoeg_strdup (absolute);
        result = monoeg_g_strconcat (prepend, codebase, 0B);
        monoeg_g_free (codebase);
        codebase = result;
      }
      <D.29416>:
      <D.29413>:
      if (codebase != 0B) goto <D.29417>; else goto <D.29418>;
      <D.29417>:
      D.29419 = &aname->codebase;
      D.29420 = mono_string_new (domain, codebase);
      mono_gc_wbarrier_set_field (aname, D.29419, D.29420);
      monoeg_g_free (codebase);
      <D.29418>:
      create_culture.99 = create_culture;
      if (create_culture.99 == 0B) goto <D.29422>; else goto <D.29423>;
      <D.29422>:
      {
        struct MonoMethodDesc * desc;

        desc = mono_method_desc_new ("System.Globalization.CultureInfo:CreateCulture(string,bool)", 1);
        D.29424 = mono_defaults.corlib;
        create_culture.100 = mono_method_desc_search_in_image (desc, D.29424);
        create_culture = create_culture.100;
        create_culture.99 = create_culture;
        D.29426 = create_culture.99 == 0B;
        D.29427 = (long int) D.29426;
        D.29428 = __builtin_expect (D.29427, 0);
        if (D.29428 != 0) goto <D.29429>; else goto <D.29430>;
        <D.29429>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "icall.c", 4954, "create_culture");
        <D.29430>:
        mono_method_desc_free (desc);
      }
      <D.29423>:
      D.29431 = name->culture;
      if (D.29431 != 0B) goto <D.29432>; else goto <D.29433>;
      <D.29432>:
      D.29431 = name->culture;
      D.29434 = mono_string_new (domain, D.29431);
      args[0] = D.29434;
      args[1] = &assembly_ref;
      D.29435 = &aname->cultureInfo;
      create_culture.99 = create_culture;
      D.29436 = mono_runtime_invoke (create_culture.99, 0B, &args, 0B);
      mono_gc_wbarrier_set_field (aname, D.29435, D.29436);
      <D.29433>:
      pkey_ptr.101 = name->public_key;
      if (pkey_ptr.101 != 0B) goto <D.29438>; else goto <D.29439>;
      <D.29438>:
      pkey_ptr.101 = name->public_key;
      pkey_ptr = pkey_ptr.101;
      pkey_ptr.102 = pkey_ptr;
      pkey_len = mono_metadata_decode_blob_size (pkey_ptr.102, &pkey_ptr);
      D.29441 = &aname->publicKey;
      D.29442 = mono_defaults.byte_class;
      D.29443 = (long unsigned int) pkey_len;
      D.29444 = mono_array_new (domain, D.29442, D.29443);
      mono_gc_wbarrier_set_field (aname, D.29441, D.29444);
      D.29445 = aname->publicKey;
      D.29446 = mono_array_addr_with_size (D.29445, 1, 0);
      pkey_ptr.102 = pkey_ptr;
      D.29447 = (long unsigned int) pkey_len;
      memcpy (D.29446, pkey_ptr.102, D.29447);
      D.29448 = aname->flags;
      D.29449 = D.29448 | 1;
      aname->flags = D.29449;
      goto <D.29450>;
      <D.29439>:
      if (default_publickey != 0) goto <D.29451>; else goto <D.29452>;
      <D.29451>:
      D.29441 = &aname->publicKey;
      D.29442 = mono_defaults.byte_class;
      D.29453 = mono_array_new (domain, D.29442, 0);
      mono_gc_wbarrier_set_field (aname, D.29441, D.29453);
      D.29448 = aname->flags;
      D.29449 = D.29448 | 1;
      aname->flags = D.29449;
      <D.29452>:
      <D.29450>:
      D.29454 = name->public_key_token[0];
      if (D.29454 != 0) goto <D.29455>; else goto <D.29456>;
      <D.29455>:
      {
        int i;
        int j;
        char * p;

        D.29457 = &aname->keyToken;
        D.29442 = mono_defaults.byte_class;
        D.29458 = mono_array_new (domain, D.29442, 8);
        mono_gc_wbarrier_set_field (aname, D.29457, D.29458);
        D.29459 = aname->keyToken;
        p = mono_array_addr_with_size (D.29459, 1, 0);
        i = 0;
        j = 0;
        goto <D.23320>;
        <D.23319>:
        j.103 = j;
        j = j.103 + 1;
        D.29461 = name->public_key_token[j.103];
        D.29462 = monoeg_g_ascii_xdigit_value (D.29461);
        D.29463 = (char) D.29462;
        D.29464 = D.29463 << 4;
        *p = D.29464;
        j.104 = j;
        j = j.104 + 1;
        D.29466 = name->public_key_token[j.104];
        D.29467 = monoeg_g_ascii_xdigit_value (D.29466);
        D.29468 = *p;
        D.29469 = (signed char) D.29468;
        D.29470 = (signed char) D.29467;
        D.29471 = D.29469 | D.29470;
        D.29472 = (char) D.29471;
        *p = D.29472;
        p = p + 1;
        i = i + 1;
        <D.23320>:
        if (i <= 7) goto <D.23319>; else goto <D.23321>;
        <D.23321>:
      }
      goto <D.29473>;
      <D.29456>:
      if (default_token != 0) goto <D.29474>; else goto <D.29475>;
      <D.29474>:
      D.29457 = &aname->keyToken;
      D.29442 = mono_defaults.byte_class;
      D.29476 = mono_array_new (domain, D.29442, 0);
      mono_gc_wbarrier_set_field (aname, D.29457, D.29476);
      <D.29475>:
      <D.29473>:
    }
  finally
    {
      args = {CLOBBER};
      pkey_ptr = {CLOBBER};
      assembly_ref = {CLOBBER};
    }
}


create_version (struct MonoDomain * domain, guint32 major, guint32 minor, guint32 build, guint32 revision)
{
  struct MonoClass * System_Version.105;
  struct MonoImage * D.29480;
  struct MonoClass * System_Version.106;
  _Bool D.29482;
  long int D.29483;
  long int D.29484;
  struct MonoMethod * create_version.107;
  struct MonoMethod * create_version.108;
  _Bool D.29491;
  long int D.29492;
  long int D.29493;
  struct MonoObject * D.29496;
  static struct MonoClass * System_Version = 0B;
  static struct MonoMethod * create_version = 0B;
  struct MonoObject * result;
  void * args[4];

  try
    {
      System_Version.105 = System_Version;
      if (System_Version.105 == 0B) goto <D.29478>; else goto <D.29479>;
      <D.29478>:
      D.29480 = mono_defaults.corlib;
      System_Version.106 = mono_class_from_name (D.29480, "System", "Version");
      System_Version = System_Version.106;
      System_Version.105 = System_Version;
      D.29482 = System_Version.105 == 0B;
      D.29483 = (long int) D.29482;
      D.29484 = __builtin_expect (D.29483, 0);
      if (D.29484 != 0) goto <D.29485>; else goto <D.29486>;
      <D.29485>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "icall.c", 4404, "System_Version");
      <D.29486>:
      <D.29479>:
      create_version.107 = create_version;
      if (create_version.107 == 0B) goto <D.29488>; else goto <D.29489>;
      <D.29488>:
      {
        struct MonoMethodDesc * desc;

        desc = mono_method_desc_new (":.ctor(int,int,int,int)", 0);
        System_Version.105 = System_Version;
        create_version.108 = mono_method_desc_search_in_class (desc, System_Version.105);
        create_version = create_version.108;
        create_version.107 = create_version;
        D.29491 = create_version.107 == 0B;
        D.29492 = (long int) D.29491;
        D.29493 = __builtin_expect (D.29492, 0);
        if (D.29493 != 0) goto <D.29494>; else goto <D.29495>;
        <D.29494>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "icall.c", 4410, "create_version");
        <D.29495>:
        mono_method_desc_free (desc);
      }
      <D.29489>:
      args[0] = &major;
      args[1] = &minor;
      args[2] = &build;
      args[3] = &revision;
      System_Version.105 = System_Version;
      result = mono_object_new (domain, System_Version.105);
      create_version.107 = create_version;
      mono_runtime_invoke (create_version.107, result, &args, 0B);
      D.29496 = result;
      return D.29496;
    }
  finally
    {
      args = {CLOBBER};
    }
}


ves_icall_System_Reflection_Assembly_load_with_partial_name (struct MonoString * mname, struct MonoObject * evidence)
{
  struct MonoReflectionAssembly * D.29501;
  struct MonoDomain * D.29502;
  gchar * name;
  struct MonoAssembly * res;
  MonoImageOpenStatus status;

  try
    {
      name = mono_string_to_utf8 (mname);
      res = mono_assembly_load_with_partial_name (name, &status);
      monoeg_g_free (name);
      if (res == 0B) goto <D.29499>; else goto <D.29500>;
      <D.29499>:
      D.29501 = 0B;
      return D.29501;
      <D.29500>:
      D.29502 = mono_domain_get ();
      D.29501 = mono_assembly_get_object (D.29502, res);
      return D.29501;
    }
  finally
    {
      status = {CLOBBER};
    }
}


ves_icall_System_Reflection_Assembly_get_location (struct MonoReflectionAssembly * assembly)
{
  struct MonoVTable * D.29505;
  struct MonoAssembly * D.29506;
  struct MonoImage * D.29507;
  const char * D.29508;
  struct MonoString * D.29509;
  struct MonoDomain * domain;
  struct MonoString * res;

  D.29505 = MEM[(struct MonoObject *)assembly].vtable;
  domain = D.29505->domain;
  D.29506 = assembly->assembly;
  D.29507 = D.29506->image;
  D.29508 = mono_image_get_filename (D.29507);
  res = mono_string_new (domain, D.29508);
  D.29509 = res;
  return D.29509;
}


ves_icall_System_Reflection_Assembly_get_global_assembly_cache (struct MonoReflectionAssembly * assembly)
{
  MonoBoolean D.29511;
  struct MonoAssembly * mass;

  mass = assembly->assembly;
  D.29511 = mass->in_gac;
  return D.29511;
}


ves_icall_System_Reflection_Assembly_get_fullName (struct MonoReflectionAssembly * assembly)
{
  struct MonoVTable * D.29513;
  struct MonoAssemblyName * D.29514;
  struct MonoString * D.29515;
  struct MonoDomain * domain;
  struct MonoAssembly * mass;
  struct MonoString * res;
  gchar * name;

  D.29513 = MEM[(struct MonoObject *)assembly].vtable;
  domain = D.29513->domain;
  mass = assembly->assembly;
  D.29514 = &mass->aname;
  name = mono_stringify_assembly_name (D.29514);
  res = mono_string_new (domain, name);
  monoeg_g_free (name);
  D.29515 = res;
  return D.29515;
}


ves_icall_System_Reflection_Assembly_get_code_base (struct MonoReflectionAssembly * assembly, MonoBoolean escaped)
{
  struct MonoVTable * D.29517;
  struct MonoImage * D.29518;
  char * D.29519;
  int D.29520;
  gchar * absolute.109;
  gchar * absolute.110;
  char * D.29526;
  gchar * absolute.111;
  struct MonoString * D.29533;
  struct MonoDomain * domain;
  struct MonoAssembly * mass;
  struct MonoString * res;
  gchar * uri;
  gchar * absolute;
  gchar * dirname;

  try
    {
      D.29517 = MEM[(struct MonoObject *)assembly].vtable;
      domain = D.29517->domain;
      mass = assembly->assembly;
      res = 0B;
      D.29518 = mass->image;
      D.29519 = D.29518->name;
      D.29520 = monoeg_g_path_is_absolute (D.29519);
      if (D.29520 != 0) goto <D.29521>; else goto <D.29522>;
      <D.29521>:
      D.29518 = mass->image;
      D.29519 = D.29518->name;
      absolute.109 = monoeg_strdup (D.29519);
      absolute = absolute.109;
      absolute.110 = absolute;
      dirname = monoeg_g_path_get_dirname (absolute.110);
      goto <D.29525>;
      <D.29522>:
      D.29526 = mass->basedir;
      D.29518 = mass->image;
      D.29519 = D.29518->name;
      absolute.111 = monoeg_g_build_path ("/", D.29526, D.29519, 0B);
      absolute = absolute.111;
      D.29526 = mass->basedir;
      dirname = monoeg_strdup (D.29526);
      <D.29525>:
      replace_shadow_path (domain, dirname, &absolute);
      monoeg_g_free (dirname);
      if (escaped != 0) goto <D.29528>; else goto <D.29529>;
      <D.29528>:
      absolute.110 = absolute;
      uri = monoeg_g_filename_to_uri (absolute.110, 0B, 0B);
      goto <D.29530>;
      <D.29529>:
      {
        const char * prepend;

        prepend = "file://";
        absolute.110 = absolute;
        uri = monoeg_g_strconcat (prepend, absolute.110, 0B);
      }
      <D.29530>:
      if (uri != 0B) goto <D.29531>; else goto <D.29532>;
      <D.29531>:
      res = mono_string_new (domain, uri);
      monoeg_g_free (uri);
      <D.29532>:
      absolute.110 = absolute;
      monoeg_g_free (absolute.110);
      D.29533 = res;
      return D.29533;
    }
  finally
    {
      absolute = {CLOBBER};
    }
}


replace_shadow_path (struct MonoDomain * domain, gchar * dirname, gchar * * filename)
{
  int D.29536;
  int D.29541;
  gchar * content.112;
  int D.29544;
  gchar * D.29549;
  gboolean D.29552;
  gchar * content;
  gchar * shadow_ini_file;
  gsize len;

  try
    {
      D.29536 = mono_is_shadow_copy_enabled (domain, dirname);
      if (D.29536 != 0) goto <D.29537>; else goto <D.29538>;
      <D.29537>:
      shadow_ini_file = monoeg_g_build_path ("/", dirname, "__AssemblyInfo__.ini", 0B);
      content = 0B;
      D.29541 = monoeg_g_file_get_contents (shadow_ini_file, &content, &len, 0B);
      if (D.29541 == 0) goto <D.29539>; else goto <D.29542>;
      <D.29542>:
      content.112 = content;
      D.29544 = monoeg_g_file_test (content.112, 1);
      if (D.29544 == 0) goto <D.29539>; else goto <D.29540>;
      <D.29539>:
      content.112 = content;
      if (content.112 != 0B) goto <D.29545>; else goto <D.29546>;
      <D.29545>:
      content.112 = content;
      monoeg_g_free (content.112);
      content = 0B;
      <D.29546>:
      <D.29540>:
      monoeg_g_free (shadow_ini_file);
      content.112 = content;
      if (content.112 != 0B) goto <D.29547>; else goto <D.29548>;
      <D.29547>:
      D.29549 = *filename;
      if (D.29549 != 0B) goto <D.29550>; else goto <D.29551>;
      <D.29550>:
      D.29549 = *filename;
      monoeg_g_free (D.29549);
      <D.29551>:
      content.112 = content;
      *filename = content.112;
      D.29552 = 1;
      return D.29552;
      <D.29548>:
      <D.29538>:
      D.29552 = 0;
      return D.29552;
    }
  finally
    {
      content = {CLOBBER};
      len = {CLOBBER};
    }
}


ves_icall_System_Reflection_Assembly_get_ReflectionOnly (struct MonoReflectionAssembly * assembly)
{
  MonoBoolean D.29555;
  struct MonoAssembly * D.29556;
  int D.29557;

  D.29556 = assembly->assembly;
  D.29557 = D.29556->ref_only;
  D.29555 = (MonoBoolean) D.29557;
  return D.29555;
}


ves_icall_System_Reflection_Assembly_get_EntryPoint (struct MonoReflectionAssembly * assembly)
{
  struct MonoAssembly * D.29559;
  struct MonoImage * D.29560;
  struct MonoReflectionMethod * D.29563;
  struct MonoVTable * D.29564;
  struct MonoDomain * D.29565;
  struct MonoMethod * D.29566;
  guint32 token;

  D.29559 = assembly->assembly;
  D.29560 = D.29559->image;
  token = mono_image_get_entry_point (D.29560);
  if (token == 0) goto <D.29561>; else goto <D.29562>;
  <D.29561>:
  D.29563 = 0B;
  return D.29563;
  <D.29562>:
  D.29564 = MEM[(struct MonoObject *)assembly].vtable;
  D.29565 = D.29564->domain;
  D.29559 = assembly->assembly;
  D.29560 = D.29559->image;
  D.29566 = mono_get_method (D.29560, token, 0B);
  D.29563 = mono_method_get_object (D.29565, D.29566, 0B);
  return D.29563;
}


ves_icall_MonoDebugger_GetMethodToken (struct MonoReflectionMethod * method)
{
  gint32 D.29568;
  struct MonoMethod * D.29569;
  unsigned int D.29570;

  D.29569 = method->method;
  D.29570 = D.29569->token;
  D.29568 = (gint32) D.29570;
  return D.29568;
}


ves_icall_System_Reflection_Assembly_LoadPermissions (struct MonoReflectionAssembly * assembly, char * * minimum, guint32 * minLength, char * * optional, guint32 * optLength, char * * refused, guint32 * refLength)
{
  struct MonoAssembly * D.29572;
  unsigned char D.29573;
  char * D.29576;
  unsigned int D.29577;
  unsigned char D.29578;
  unsigned char D.29581;
  MonoBoolean D.29584;
  MonoBoolean result;
  struct MonoDeclSecurityEntry entry;

  try
    {
      result = 0;
      D.29572 = assembly->assembly;
      D.29573 = mono_declsec_get_assembly_action (D.29572, 8, &entry);
      if (D.29573 != 0) goto <D.29574>; else goto <D.29575>;
      <D.29574>:
      D.29576 = entry.blob;
      *minimum = D.29576;
      D.29577 = entry.size;
      *minLength = D.29577;
      result = 1;
      <D.29575>:
      D.29572 = assembly->assembly;
      D.29578 = mono_declsec_get_assembly_action (D.29572, 9, &entry);
      if (D.29578 != 0) goto <D.29579>; else goto <D.29580>;
      <D.29579>:
      D.29576 = entry.blob;
      *optional = D.29576;
      D.29577 = entry.size;
      *optLength = D.29577;
      result = 1;
      <D.29580>:
      D.29572 = assembly->assembly;
      D.29581 = mono_declsec_get_assembly_action (D.29572, 10, &entry);
      if (D.29581 != 0) goto <D.29582>; else goto <D.29583>;
      <D.29582>:
      D.29576 = entry.blob;
      *refused = D.29576;
      D.29577 = entry.size;
      *refLength = D.29577;
      result = 1;
      <D.29583>:
      D.29584 = result;
      return D.29584;
    }
  finally
    {
      entry = {CLOBBER};
    }
}


ves_icall_System_Reflection_Assembly_InternalImageRuntimeVersion (struct MonoReflectionAssembly * assembly)
{
  struct MonoVTable * D.29587;
  struct MonoString * D.29588;
  struct MonoAssembly * D.29589;
  struct MonoImage * D.29590;
  char * D.29591;
  struct MonoDomain * domain;

  D.29587 = MEM[(struct MonoObject *)assembly].vtable;
  domain = D.29587->domain;
  D.29589 = assembly->assembly;
  D.29590 = D.29589->image;
  D.29591 = D.29590->version;
  D.29588 = mono_string_new (domain, D.29591);
  return D.29588;
}


ves_icall_System_Reflection_Assembly_InternalGetType (struct MonoReflectionAssembly * assembly, struct MonoReflectionModule * module, struct MonoString * name, MonoBoolean throwOnError, MonoBoolean ignoreCase)
{
  int D.29593;
  struct MonoException * D.29598;
  struct MonoReflectionType * D.29599;
  const char * D.29600;
  struct MonoClass * D.29605;
  struct MonoException * D.29608;
  struct MonoException * D.29610;
  struct MonoImage * D.29613;
  int D.29616;
  struct MonoAssembly * D.29619;
  unsigned char D.29620;
  struct MonoArray * D.29623;
  long unsigned int D.29626;
  char * D.29627;
  struct MonoDynamicImage * D.29628;
  struct MonoImage * D.29629;
  long unsigned int D.29631;
  struct MonoArray * D.29634;
  char * D.29637;
  struct MonoImage * D.29638;
  long unsigned int D.29640;
  struct MonoImage * D.29642;
  struct MonoLoaderError * D.29647;
  struct MonoLoaderError * D.29652;
  struct MonoLoaderError * D.29655;
  struct MonoLoaderError * D.29660;
  struct MonoException * D.29661;
  unsigned char D.29662;
  int D.29665;
  unsigned char D.29668;
  int D.29675;
  struct MonoVTable * D.29680;
  struct MonoDomain * D.29681;
  gchar * str;
  struct MonoType * type;
  struct MonoTypeNameParse info;
  gboolean type_resolve;

  try
    {
      type = 0B;
      type_resolve = 1;
      str = mono_string_to_utf8 (name);
      D.29593 = mono_reflection_parse_type (str, &info);
      if (D.29593 == 0) goto <D.29594>; else goto <D.29595>;
      <D.29594>:
      monoeg_g_free (str);
      mono_reflection_free_type_info (&info);
      if (throwOnError != 0) goto <D.29596>; else goto <D.29597>;
      <D.29596>:
      D.29598 = mono_get_exception_type_load (name, 0B);
      mono_raise_exception (D.29598);
      <D.29597>:
      D.29599 = 0B;
      return D.29599;
      <D.29595>:
      D.29600 = info.assembly.name;
      if (D.29600 != 0B) goto <D.29601>; else goto <D.29602>;
      <D.29601>:
      monoeg_g_free (str);
      mono_reflection_free_type_info (&info);
      if (throwOnError != 0) goto <D.29603>; else goto <D.29604>;
      <D.29603>:
      D.29605 = mono_defaults.generic_ilist_class;
      if (D.29605 != 0B) goto <D.29606>; else goto <D.29607>;
      <D.29606>:
      D.29608 = mono_get_exception_argument (0B, "Type names passed to Assembly.GetType() must not specify an assembly.");
      mono_raise_exception (D.29608);
      goto <D.29609>;
      <D.29607>:
      D.29610 = mono_get_exception_type_load (name, 0B);
      mono_raise_exception (D.29610);
      <D.29609>:
      <D.29604>:
      D.29599 = 0B;
      return D.29599;
      <D.29602>:
      if (module != 0B) goto <D.29611>; else goto <D.29612>;
      <D.29611>:
      D.29613 = module->image;
      if (D.29613 != 0B) goto <D.29614>; else goto <D.29615>;
      <D.29614>:
      D.29613 = module->image;
      D.29616 = (int) ignoreCase;
      type = mono_reflection_get_type (D.29613, &info, D.29616, &type_resolve);
      goto <D.29617>;
      <D.29615>:
      type = 0B;
      <D.29617>:
      goto <D.29618>;
      <D.29612>:
      D.29619 = assembly->assembly;
      D.29620 = D.29619->dynamic;
      if (D.29620 != 0) goto <D.29621>; else goto <D.29622>;
      <D.29621>:
      {
        struct MonoReflectionAssemblyBuilder * abuilder;
        int i;

        abuilder = assembly;
        type = 0B;
        D.29623 = abuilder->modules;
        if (D.29623 != 0B) goto <D.29624>; else goto <D.29625>;
        <D.29624>:
        i = 0;
        goto <D.23021>;
        <D.23020>:
        {
          struct MonoReflectionModuleBuilder * mb;

          D.29623 = abuilder->modules;
          D.29626 = (long unsigned int) i;
          D.29627 = mono_array_addr_with_size (D.29623, 8, D.29626);
          mb = MEM[(struct MonoReflectionModuleBuilder * *)D.29627];
          D.29628 = mb->dynamic_image;
          D.29629 = &D.29628->image;
          D.29616 = (int) ignoreCase;
          type = mono_reflection_get_type (D.29629, &info, D.29616, &type_resolve);
          if (type != 0B) goto <D.23019>; else goto <D.29630>;
          <D.29630>:
        }
        i = i + 1;
        <D.23021>:
        D.29626 = (long unsigned int) i;
        D.29623 = abuilder->modules;
        D.29631 = mono_array_length (D.29623);
        if (D.29626 < D.29631) goto <D.23020>; else goto <D.23019>;
        <D.23019>:
        <D.29625>:
        if (type == 0B) goto <D.29632>; else goto <D.29633>;
        <D.29632>:
        D.29634 = abuilder->loaded_modules;
        if (D.29634 != 0B) goto <D.29635>; else goto <D.29636>;
        <D.29635>:
        i = 0;
        goto <D.23025>;
        <D.23024>:
        {
          struct MonoReflectionModule * mod;

          D.29634 = abuilder->loaded_modules;
          D.29626 = (long unsigned int) i;
          D.29637 = mono_array_addr_with_size (D.29634, 8, D.29626);
          mod = MEM[(struct MonoReflectionModule * *)D.29637];
          D.29638 = mod->image;
          D.29616 = (int) ignoreCase;
          type = mono_reflection_get_type (D.29638, &info, D.29616, &type_resolve);
          if (type != 0B) goto <D.23023>; else goto <D.29639>;
          <D.29639>:
        }
        i = i + 1;
        <D.23025>:
        D.29626 = (long unsigned int) i;
        D.29634 = abuilder->loaded_modules;
        D.29640 = mono_array_length (D.29634);
        if (D.29626 < D.29640) goto <D.23024>; else goto <D.23023>;
        <D.23023>:
        <D.29636>:
        <D.29633>:
      }
      goto <D.29641>;
      <D.29622>:
      D.29619 = assembly->assembly;
      D.29642 = D.29619->image;
      D.29616 = (int) ignoreCase;
      type = mono_reflection_get_type (D.29642, &info, D.29616, &type_resolve);
      <D.29641>:
      <D.29618>:
      monoeg_g_free (str);
      mono_reflection_free_type_info (&info);
      if (type == 0B) goto <D.29643>; else goto <D.29644>;
      <D.29643>:
      {
        struct MonoException * e;

        e = 0B;
        if (throwOnError != 0) goto <D.29645>; else goto <D.29646>;
        <D.29645>:
        e = mono_get_exception_type_load (name, 0B);
        <D.29646>:
        D.29647 = mono_loader_get_last_error ();
        if (D.29647 != 0B) goto <D.29648>; else goto <D.29649>;
        <D.29648>:
        D.29605 = mono_defaults.generic_ilist_class;
        if (D.29605 != 0B) goto <D.29650>; else goto <D.29651>;
        <D.29650>:
        D.29652 = mono_loader_get_last_error ();
        e = mono_loader_error_prepare_exception (D.29652);
        <D.29651>:
        <D.29649>:
        mono_loader_clear_error ();
        if (e != 0B) goto <D.29653>; else goto <D.29654>;
        <D.29653>:
        mono_raise_exception (e);
        <D.29654>:
        D.29599 = 0B;
        return D.29599;
      }
      <D.29644>:
      D.29655 = mono_loader_get_last_error ();
      if (D.29655 != 0B) goto <D.29656>; else goto <D.29657>;
      <D.29656>:
      if (throwOnError != 0) goto <D.29658>; else goto <D.29659>;
      <D.29658>:
      D.29660 = mono_loader_get_last_error ();
      D.29661 = mono_loader_error_prepare_exception (D.29660);
      mono_raise_exception (D.29661);
      <D.29659>:
      mono_loader_clear_error ();
      <D.29657>:
      D.29662 = type->type;
      if (D.29662 == 18) goto <D.29663>; else goto <D.29664>;
      <D.29663>:
      {
        struct MonoClass * klass;

        klass = mono_type_get_class (type);
        D.29665 = mono_is_security_manager_active ();
        if (D.29665 != 0) goto <D.29666>; else goto <D.29667>;
        <D.29666>:
        D.29668 = klass->exception_type;
        if (D.29668 == 0) goto <D.29669>; else goto <D.29670>;
        <D.29669>:
        mono_class_setup_vtable (klass);
        <D.29670>:
        <D.29667>:
        if (throwOnError != 0) goto <D.29673>; else goto <D.29671>;
        <D.29673>:
        D.29668 = klass->exception_type;
        if (D.29668 != 0) goto <D.29674>; else goto <D.29671>;
        <D.29674>:
        {
          struct MonoException * exc;

          exc = mono_class_get_exception_for_failure (klass);
          mono_loader_clear_error ();
          mono_raise_exception (exc);
        }
        goto <D.29672>;
        <D.29671>:
        D.29675 = mono_is_security_manager_active ();
        if (D.29675 != 0) goto <D.29676>; else goto <D.29677>;
        <D.29676>:
        D.29668 = klass->exception_type;
        if (D.29668 == 2) goto <D.29678>; else goto <D.29679>;
        <D.29678>:
        D.29599 = 0B;
        return D.29599;
        <D.29679>:
        <D.29677>:
        <D.29672>:
      }
      <D.29664>:
      D.29680 = MEM[(struct MonoObject *)assembly].vtable;
      D.29681 = D.29680->domain;
      D.29599 = mono_type_get_object (D.29681, type);
      return D.29599;
    }
  finally
    {
      info = {CLOBBER};
      type_resolve = {CLOBBER};
    }
}


ves_icall_System_Reflection_Assembly_InternalGetAssemblyName (struct MonoString * fname, struct MonoReflectionAssemblyName * aname)
{
  char * filename.113;
  char * filename.114;
  struct MonoDomain * D.29686;
  <unnamed type> status.115;
  struct MonoException * D.29695;
  struct MonoDomain * D.29696;
  char * filename;
  MonoImageOpenStatus status;
  gboolean res;
  struct MonoImage * image;
  struct MonoAssemblyName name;
  char * dirname;

  try
    {
      status = 0;
      filename.113 = mono_string_to_utf8 (fname);
      filename = filename.113;
      filename.114 = filename;
      dirname = monoeg_g_path_get_dirname (filename.114);
      D.29686 = mono_domain_get ();
      replace_shadow_path (D.29686, dirname, &filename);
      monoeg_g_free (dirname);
      filename.114 = filename;
      image = mono_image_open (filename.114, &status);
      if (image == 0B) goto <D.29687>; else goto <D.29688>;
      <D.29687>:
      {
        struct MonoException * exc;

        filename.114 = filename;
        monoeg_g_free (filename.114);
        status.115 = status;
        if (status.115 == 3) goto <D.29690>; else goto <D.29691>;
        <D.29690>:
        exc = mono_get_exception_bad_image_format2 (0B, fname);
        goto <D.29692>;
        <D.29691>:
        exc = mono_get_exception_file_not_found2 (0B, fname);
        <D.29692>:
        mono_raise_exception (exc);
      }
      <D.29688>:
      res = mono_assembly_fill_assembly_name (image, &name);
      if (res == 0) goto <D.29693>; else goto <D.29694>;
      <D.29693>:
      mono_image_close (image);
      filename.114 = filename;
      monoeg_g_free (filename.114);
      D.29695 = mono_get_exception_argument ("assemblyFile", "The file does not contain a manifest");
      mono_raise_exception (D.29695);
      <D.29694>:
      D.29696 = mono_domain_get ();
      filename.114 = filename;
      fill_reflection_assembly_name (D.29696, aname, &name, filename.114, 1, 0, 1);
      filename.114 = filename;
      monoeg_g_free (filename.114);
      mono_image_close (image);
    }
  finally
    {
      filename = {CLOBBER};
      status = {CLOBBER};
      name = {CLOBBER};
    }
}


ves_icall_System_Reflection_Assembly_GetTypes (struct MonoReflectionAssembly * assembly, MonoBoolean exportedOnly)
{
  struct MonoVTable * D.29697;
  struct MonoAssembly * D.29698;
  unsigned char D.29699;
  _Bool D.29700;
  long int D.29701;
  long int D.29702;
  unsigned int D.29705;
  unsigned int D.29706;
  struct MonoAssembly * D.29709;
  int D.29710;
  unsigned int D.29711;
  long unsigned int D.29714;
  long unsigned int D.29717;
  long unsigned int D.29718;
  struct MonoClass * D.29719;
  unsigned int D.29720;
  long unsigned int D.29721;
  int len1.116;
  long unsigned int D.29723;
  int len2.117;
  struct MonoArray * exceptions.118;
  struct MonoArray * ex2.119;
  <unnamed-unsigned:24> D.29727;
  int D.29728;
  long unsigned int D.29729;
  long unsigned int D.29730;
  char * D.29731;
  struct MonoType * D.29734;
  unsigned char D.29737;
  unsigned int D.29744;
  unsigned int ex_count.120;
  unsigned int D.29746;
  struct MonoClass * D.29747;
  long unsigned int D.29748;
  void * D.29749;
  long unsigned int D.29750;
  char * D.29751;
  _Bool D.29754;
  long int D.29755;
  long int D.29756;
  long unsigned int D.29759;
  struct MonoArray * D.29760;
  struct MonoArray * res;
  struct MonoArray * exceptions;
  struct MonoImage * image;
  struct MonoTableInfo * table;
  struct MonoDomain * domain;
  struct GList * list;
  int i;
  int len;
  int ex_count;

  try
    {
      res = 0B;
      exceptions = 0B;
      image = 0B;
      table = 0B;
      list = 0B;
      D.29697 = MEM[(struct MonoObject *)assembly].vtable;
      domain = D.29697->domain;
      D.29698 = assembly->assembly;
      D.29699 = D.29698->dynamic;
      D.29700 = D.29699 != 0;
      D.29701 = (long int) D.29700;
      D.29702 = __builtin_expect (D.29701, 0);
      if (D.29702 != 0) goto <D.29703>; else goto <D.29704>;
      <D.29703>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "icall.c", 5171, "!assembly->assembly->dynamic");
      <D.29704>:
      D.29698 = assembly->assembly;
      image = D.29698->image;
      table = &image->tables[38];
      res = mono_module_get_types (domain, image, &exceptions, exportedOnly);
      i = 0;
      goto <D.23409>;
      <D.23408>:
      D.29705 = mono_metadata_decode_row_col (table, i, 0);
      D.29706 = D.29705 & 1;
      if (D.29706 == 0) goto <D.29707>; else goto <D.29708>;
      <D.29707>:
      {
        struct MonoImage * loaded_image;

        D.29709 = image->assembly;
        D.29710 = i + 1;
        D.29711 = (unsigned int) D.29710;
        loaded_image = mono_assembly_load_module (D.29709, D.29711);
        if (loaded_image != 0B) goto <D.29712>; else goto <D.29713>;
        <D.29712>:
        {
          struct MonoArray * ex2;
          struct MonoArray * res2;

          try
            {
              res2 = mono_module_get_types (domain, loaded_image, &ex2, exportedOnly);
              D.29714 = mono_array_length (res2);
              if (D.29714 != 0) goto <D.29715>; else goto <D.29716>;
              <D.29715>:
              {
                guint32 len1;
                guint32 len2;
                struct MonoArray * res3;
                struct MonoArray * ex3;

                D.29717 = mono_array_length (res);
                len1 = (guint32) D.29717;
                D.29718 = mono_array_length (res2);
                len2 = (guint32) D.29718;
                D.29719 = mono_defaults.monotype_class;
                D.29720 = len1 + len2;
                D.29721 = (long unsigned int) D.29720;
                res3 = mono_array_new (domain, D.29719, D.29721);
                {
                  void * * __p;
                  void * * __s;

                  __p = mono_array_addr_with_size (res3, 8, 0);
                  __s = mono_array_addr_with_size (res, 8, 0);
                  len1.116 = (int) len1;
                  mono_gc_wbarrier_arrayref_copy (__p, __s, len1.116);
                }
                {
                  void * * __p;
                  void * * __s;

                  D.29723 = (long unsigned int) len1;
                  __p = mono_array_addr_with_size (res3, 8, D.29723);
                  __s = mono_array_addr_with_size (res2, 8, 0);
                  len2.117 = (int) len2;
                  mono_gc_wbarrier_arrayref_copy (__p, __s, len2.117);
                }
                res = res3;
                D.29719 = mono_defaults.monotype_class;
                D.29720 = len1 + len2;
                D.29721 = (long unsigned int) D.29720;
                ex3 = mono_array_new (domain, D.29719, D.29721);
                {
                  void * * __p;
                  void * * __s;

                  __p = mono_array_addr_with_size (ex3, 8, 0);
                  exceptions.118 = exceptions;
                  __s = mono_array_addr_with_size (exceptions.118, 8, 0);
                  len1.116 = (int) len1;
                  mono_gc_wbarrier_arrayref_copy (__p, __s, len1.116);
                }
                {
                  void * * __p;
                  void * * __s;

                  D.29723 = (long unsigned int) len1;
                  __p = mono_array_addr_with_size (ex3, 8, D.29723);
                  ex2.119 = ex2;
                  __s = mono_array_addr_with_size (ex2.119, 8, 0);
                  len2.117 = (int) len2;
                  mono_gc_wbarrier_arrayref_copy (__p, __s, len2.117);
                }
                exceptions = ex3;
              }
              <D.29716>:
            }
          finally
            {
              ex2 = {CLOBBER};
            }
        }
        <D.29713>:
      }
      <D.29708>:
      i = i + 1;
      <D.23409>:
      D.29727 = table->rows;
      D.29728 = (int) D.29727;
      if (D.29728 > i) goto <D.23408>; else goto <D.23410>;
      <D.23410>:
      D.29729 = mono_array_length (res);
      len = (int) D.29729;
      ex_count = 0;
      i = 0;
      goto <D.23415>;
      <D.23414>:
      {
        struct MonoReflectionType * t;
        struct MonoClass * klass;

        D.29730 = (long unsigned int) i;
        D.29731 = mono_array_addr_with_size (res, 8, D.29730);
        t = MEM[(void * *)D.29731];
        if (t != 0B) goto <D.29732>; else goto <D.29733>;
        <D.29732>:
        D.29734 = t->type;
        klass = mono_type_get_class (D.29734);
        if (klass != 0B) goto <D.29735>; else goto <D.29736>;
        <D.29735>:
        D.29737 = klass->exception_type;
        if (D.29737 != 0) goto <D.29738>; else goto <D.29739>;
        <D.29738>:
        list = monoeg_g_list_append (list, klass);
        {
          void * * __p;

          D.29730 = (long unsigned int) i;
          __p = mono_array_addr_with_size (res, 8, D.29730);
          mono_gc_wbarrier_set_arrayref (res, __p, 0B);
        }
        <D.29739>:
        <D.29736>:
        goto <D.29740>;
        <D.29733>:
        ex_count = ex_count + 1;
        <D.29740>:
      }
      i = i + 1;
      <D.23415>:
      if (i < len) goto <D.23414>; else goto <D.23416>;
      <D.23416>:
      if (list != 0B) goto <D.29741>; else goto <D.29743>;
      <D.29743>:
      if (ex_count != 0) goto <D.29741>; else goto <D.29742>;
      <D.29741>:
      {
        struct GList * tmp;
        struct MonoException * exc;
        struct MonoArray * exl;
        int j;
        int length;

        tmp = 0B;
        exc = 0B;
        exl = 0B;
        D.29744 = monoeg_g_list_length (list);
        ex_count.120 = (unsigned int) ex_count;
        D.29746 = D.29744 + ex_count.120;
        length = (int) D.29746;
        mono_loader_clear_error ();
        D.29747 = mono_defaults.exception_class;
        D.29748 = (long unsigned int) length;
        exl = mono_array_new (domain, D.29747, D.29748);
        i = 0;
        tmp = list;
        goto <D.23425>;
        <D.23424>:
        {
          struct MonoException * exc;

          D.29749 = tmp->data;
          exc = mono_class_get_exception_for_failure (D.29749);
          {
            void * * __p;

            D.29730 = (long unsigned int) i;
            __p = mono_array_addr_with_size (exl, 8, D.29730);
            mono_gc_wbarrier_set_arrayref (exl, __p, exc);
          }
        }
        i = i + 1;
        tmp = tmp->next;
        <D.23425>:
        if (tmp != 0B) goto <D.23424>; else goto <D.23426>;
        <D.23426>:
        j = 0;
        goto <D.23430>;
        <D.23429>:
        {
          struct MonoException * exc;

          exceptions.118 = exceptions;
          D.29750 = (long unsigned int) j;
          D.29751 = mono_array_addr_with_size (exceptions.118, 8, D.29750);
          exc = MEM[(struct MonoException * *)D.29751];
          if (exc != 0B) goto <D.29752>; else goto <D.29753>;
          <D.29752>:
          D.29754 = i >= length;
          D.29755 = (long int) D.29754;
          D.29756 = __builtin_expect (D.29755, 0);
          if (D.29756 != 0) goto <D.29757>; else goto <D.29758>;
          <D.29757>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "icall.c", 5248, "i < length");
          <D.29758>:
          {
            void * * __p;

            D.29730 = (long unsigned int) i;
            __p = mono_array_addr_with_size (exl, 8, D.29730);
            mono_gc_wbarrier_set_arrayref (exl, __p, exc);
          }
          i = i + 1;
          <D.29753>:
        }
        j = j + 1;
        <D.23430>:
        D.29750 = (long unsigned int) j;
        exceptions.118 = exceptions;
        D.29759 = mono_array_length (exceptions.118);
        if (D.29750 < D.29759) goto <D.23429>; else goto <D.23431>;
        <D.23431>:
        monoeg_g_list_free (list);
        list = 0B;
        exc = mono_get_exception_reflection_type_load (res, exl);
        mono_loader_clear_error ();
        mono_raise_exception (exc);
      }
      <D.29742>:
      D.29760 = res;
      return D.29760;
    }
  finally
    {
      exceptions = {CLOBBER};
    }
}


ves_icall_System_Reflection_Assembly_GetReferencedAssemblies (struct MonoReflectionAssembly * assembly)
{
  struct MonoVTable * D.29763;
  struct MonoAssembly * D.29764;
  struct MonoClass * System_Reflection_AssemblyName.121;
  struct MonoImage * D.29768;
  struct MonoClass * System_Reflection_AssemblyName.122;
  struct MonoImage * D.29770;
  <unnamed-unsigned:24> D.29771;
  long unsigned int D.29772;
  struct MonoMethod * create_culture.123;
  struct MonoMethod * create_culture.124;
  _Bool D.29779;
  long int D.29780;
  long int D.29781;
  struct MonoString * * D.29784;
  unsigned int D.29785;
  const char * D.29786;
  struct MonoString * D.29787;
  unsigned int D.29788;
  int D.29789;
  unsigned int D.29790;
  int D.29791;
  unsigned int D.29792;
  int D.29793;
  unsigned int D.29794;
  int D.29795;
  unsigned int D.29796;
  struct MonoObject * * D.29797;
  int D.29798;
  unsigned int D.29799;
  int D.29800;
  unsigned int D.29801;
  int D.29802;
  unsigned int D.29803;
  int D.29804;
  unsigned int D.29805;
  struct MonoObject * D.29806;
  unsigned int D.29809;
  const char * D.29810;
  struct MonoString * D.29811;
  struct MonoObject * * D.29812;
  struct MonoObject * D.29813;
  unsigned int D.29814;
  const char * pkey_ptr.125;
  const gchar * pkey_ptr.126;
  unsigned int D.29819;
  struct MonoArray * * D.29822;
  struct MonoClass * D.29823;
  long unsigned int D.29824;
  struct MonoArray * D.29825;
  struct MonoArray * D.29826;
  char * D.29827;
  long unsigned int D.29828;
  struct MonoArray * * D.29830;
  struct MonoArray * D.29831;
  struct MonoArray * D.29832;
  char * D.29833;
  struct MonoArray * D.29835;
  long unsigned int D.29836;
  struct MonoArray * D.29837;
  static struct MonoClass * System_Reflection_AssemblyName;
  struct MonoArray * result;
  struct MonoDomain * domain;
  int i;
  int count;
  static struct MonoMethod * create_culture = 0B;
  struct MonoImage * image;
  struct MonoTableInfo * t;

  D.29763 = MEM[(struct MonoObject *)assembly].vtable;
  domain = D.29763->domain;
  count = 0;
  D.29764 = assembly->assembly;
  image = D.29764->image;
  System_Reflection_AssemblyName.121 = System_Reflection_AssemblyName;
  if (System_Reflection_AssemblyName.121 == 0B) goto <D.29766>; else goto <D.29767>;
  <D.29766>:
  D.29768 = mono_defaults.corlib;
  System_Reflection_AssemblyName.122 = mono_class_from_name (D.29768, "System.Reflection", "AssemblyName");
  System_Reflection_AssemblyName = System_Reflection_AssemblyName.122;
  <D.29767>:
  D.29764 = assembly->assembly;
  D.29770 = D.29764->image;
  t = &D.29770->tables[35];
  D.29771 = t->rows;
  count = (int) D.29771;
  System_Reflection_AssemblyName.121 = System_Reflection_AssemblyName;
  D.29772 = (long unsigned int) count;
  result = mono_array_new (domain, System_Reflection_AssemblyName.121, D.29772);
  if (count > 0) goto <D.29773>; else goto <D.29774>;
  <D.29773>:
  create_culture.123 = create_culture;
  if (create_culture.123 == 0B) goto <D.29776>; else goto <D.29777>;
  <D.29776>:
  {
    struct MonoMethodDesc * desc;

    desc = mono_method_desc_new ("System.Globalization.CultureInfo:CreateCulture(string,bool)", 1);
    D.29768 = mono_defaults.corlib;
    create_culture.124 = mono_method_desc_search_in_image (desc, D.29768);
    create_culture = create_culture.124;
    create_culture.123 = create_culture;
    D.29779 = create_culture.123 == 0B;
    D.29780 = (long int) D.29779;
    D.29781 = __builtin_expect (D.29780, 0);
    if (D.29781 != 0) goto <D.29782>; else goto <D.29783>;
    <D.29782>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "icall.c", 4450, "create_culture");
    <D.29783>:
    mono_method_desc_free (desc);
  }
  <D.29777>:
  <D.29774>:
  i = 0;
  goto <D.23121>;
  <D.23120>:
  {
    struct MonoReflectionAssemblyName * aname;
    guint32 cols[9];

    try
      {
        mono_metadata_decode_row (t, i, &cols, 9);
        System_Reflection_AssemblyName.121 = System_Reflection_AssemblyName;
        aname = mono_object_new (domain, System_Reflection_AssemblyName.121);
        D.29784 = &aname->name;
        D.29785 = cols[6];
        D.29786 = mono_metadata_string_heap (image, D.29785);
        D.29787 = mono_string_new (domain, D.29786);
        mono_gc_wbarrier_set_field (aname, D.29784, D.29787);
        D.29788 = cols[0];
        D.29789 = (int) D.29788;
        aname->major = D.29789;
        D.29790 = cols[1];
        D.29791 = (int) D.29790;
        aname->minor = D.29791;
        D.29792 = cols[2];
        D.29793 = (int) D.29792;
        aname->build = D.29793;
        D.29794 = cols[3];
        D.29795 = (int) D.29794;
        aname->revision = D.29795;
        D.29796 = cols[4];
        aname->flags = D.29796;
        aname->versioncompat = 1;
        aname->hashalg = 32772;
        D.29797 = &aname->version;
        D.29798 = aname->major;
        D.29799 = (unsigned int) D.29798;
        D.29800 = aname->minor;
        D.29801 = (unsigned int) D.29800;
        D.29802 = aname->build;
        D.29803 = (unsigned int) D.29802;
        D.29804 = aname->revision;
        D.29805 = (unsigned int) D.29804;
        D.29806 = create_version (domain, D.29799, D.29801, D.29803, D.29805);
        mono_gc_wbarrier_set_field (aname, D.29797, D.29806);
        create_culture.123 = create_culture;
        if (create_culture.123 != 0B) goto <D.29807>; else goto <D.29808>;
        <D.29807>:
        {
          void * args[2];
          MonoBoolean assembly_ref;

          try
            {
              assembly_ref = 1;
              D.29809 = cols[7];
              D.29810 = mono_metadata_string_heap (image, D.29809);
              D.29811 = mono_string_new (domain, D.29810);
              args[0] = D.29811;
              args[1] = &assembly_ref;
              D.29812 = &aname->cultureInfo;
              create_culture.123 = create_culture;
              D.29813 = mono_runtime_invoke (create_culture.123, 0B, &args, 0B);
              mono_gc_wbarrier_set_field (aname, D.29812, D.29813);
            }
          finally
            {
              args = {CLOBBER};
              assembly_ref = {CLOBBER};
            }
        }
        <D.29808>:
        D.29814 = cols[5];
        if (D.29814 != 0) goto <D.29815>; else goto <D.29816>;
        <D.29815>:
        {
          const gchar * pkey_ptr;
          guint32 pkey_len;

          try
            {
              D.29814 = cols[5];
              pkey_ptr.125 = mono_metadata_blob_heap (image, D.29814);
              pkey_ptr = pkey_ptr.125;
              pkey_ptr.126 = pkey_ptr;
              pkey_len = mono_metadata_decode_blob_size (pkey_ptr.126, &pkey_ptr);
              D.29796 = cols[4];
              D.29819 = D.29796 & 1;
              if (D.29819 != 0) goto <D.29820>; else goto <D.29821>;
              <D.29820>:
              D.29822 = &aname->publicKey;
              D.29823 = mono_defaults.byte_class;
              D.29824 = (long unsigned int) pkey_len;
              D.29825 = mono_array_new (domain, D.29823, D.29824);
              mono_gc_wbarrier_set_field (aname, D.29822, D.29825);
              D.29826 = aname->publicKey;
              D.29827 = mono_array_addr_with_size (D.29826, 1, 0);
              pkey_ptr.126 = pkey_ptr;
              D.29828 = (long unsigned int) pkey_len;
              memcpy (D.29827, pkey_ptr.126, D.29828);
              goto <D.29829>;
              <D.29821>:
              D.29830 = &aname->keyToken;
              D.29823 = mono_defaults.byte_class;
              D.29824 = (long unsigned int) pkey_len;
              D.29831 = mono_array_new (domain, D.29823, D.29824);
              mono_gc_wbarrier_set_field (aname, D.29830, D.29831);
              D.29832 = aname->keyToken;
              D.29833 = mono_array_addr_with_size (D.29832, 1, 0);
              pkey_ptr.126 = pkey_ptr;
              D.29828 = (long unsigned int) pkey_len;
              memcpy (D.29833, pkey_ptr.126, D.29828);
              <D.29829>:
            }
          finally
            {
              pkey_ptr = {CLOBBER};
            }
        }
        goto <D.29834>;
        <D.29816>:
        D.29830 = &aname->keyToken;
        D.29823 = mono_defaults.byte_class;
        D.29835 = mono_array_new (domain, D.29823, 0);
        mono_gc_wbarrier_set_field (aname, D.29830, D.29835);
        <D.29834>:
        {
          void * * __p;

          D.29836 = (long unsigned int) i;
          __p = mono_array_addr_with_size (result, 8, D.29836);
          mono_gc_wbarrier_set_arrayref (result, __p, aname);
        }
      }
    finally
      {
        cols = {CLOBBER};
      }
  }
  i = i + 1;
  <D.23121>:
  if (i < count) goto <D.23120>; else goto <D.23122>;
  <D.23122>:
  D.29837 = result;
  return D.29837;
}


ves_icall_System_Reflection_Assembly_GetModulesInternal (struct MonoReflectionAssembly * assembly)
{
  struct MonoAssembly * D.29839;
  _Bool D.29840;
  long int D.29841;
  long int D.29842;
  unsigned char D.29845;
  _Bool D.29846;
  long int D.29847;
  long int D.29848;
  <unnamed-unsigned:24> D.29851;
  long unsigned int D.29852;
  long unsigned int D.29853;
  struct MonoImage * * D.29854;
  struct MonoImage * D.29855;
  unsigned int i.127;
  struct MonoImage * D.29859;
  unsigned int file_count.128;
  unsigned int D.29861;
  unsigned int D.29862;
  long unsigned int D.29863;
  struct MonoReflectionModule * D.29864;
  long unsigned int D.29867;
  struct MonoReflectionModule * D.29868;
  unsigned int D.29869;
  struct MonoReflectionModule * D.29872;
  int D.29874;
  struct MonoDomain * D.29877;
  unsigned int D.29878;
  const char * D.29879;
  struct MonoException * D.29880;
  struct MonoReflectionModule * D.29881;
  struct MonoArray * D.29882;
  struct MonoDomain * domain;
  struct MonoArray * res;
  struct MonoClass * klass;
  int i;
  int j;
  int file_count;
  struct MonoImage * * modules;
  guint32 module_count;
  guint32 real_module_count;
  struct MonoTableInfo * table;
  guint32 cols[3];
  struct MonoImage * image;

  try
    {
      domain = mono_domain_get ();
      file_count = 0;
      D.29839 = assembly->assembly;
      image = D.29839->image;
      D.29840 = image == 0B;
      D.29841 = (long int) D.29840;
      D.29842 = __builtin_expect (D.29841, 0);
      if (D.29842 != 0) goto <D.29843>; else goto <D.29844>;
      <D.29843>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "icall.c", 4696, "image != NULL");
      <D.29844>:
      D.29839 = assembly->assembly;
      D.29845 = D.29839->dynamic;
      D.29846 = D.29845 != 0;
      D.29847 = (long int) D.29846;
      D.29848 = __builtin_expect (D.29847, 0);
      if (D.29848 != 0) goto <D.29849>; else goto <D.29850>;
      <D.29849>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "icall.c", 4697, "!assembly->assembly->dynamic");
      <D.29850>:
      table = &image->tables[38];
      D.29851 = table->rows;
      file_count = (int) D.29851;
      modules = image->modules;
      module_count = image->module_count;
      real_module_count = 0;
      i = 0;
      goto <D.23229>;
      <D.23228>:
      D.29852 = (long unsigned int) i;
      D.29853 = D.29852 * 8;
      D.29854 = modules + D.29853;
      D.29855 = *D.29854;
      if (D.29855 != 0B) goto <D.29856>; else goto <D.29857>;
      <D.29856>:
      real_module_count = real_module_count + 1;
      <D.29857>:
      i = i + 1;
      <D.23229>:
      i.127 = (unsigned int) i;
      if (i.127 < module_count) goto <D.23228>; else goto <D.23230>;
      <D.23230>:
      D.29859 = mono_defaults.corlib;
      klass = mono_class_from_name (D.29859, "System.Reflection", "Module");
      file_count.128 = (unsigned int) file_count;
      D.29861 = real_module_count + file_count.128;
      D.29862 = D.29861 + 1;
      D.29863 = (long unsigned int) D.29862;
      res = mono_array_new (domain, klass, D.29863);
      {
        void * * __p;

        __p = mono_array_addr_with_size (res, 8, 0);
        D.29864 = mono_module_get_object (domain, image);
        mono_gc_wbarrier_set_arrayref (res, __p, D.29864);
      }
      j = 1;
      i = 0;
      goto <D.23234>;
      <D.23233>:
      D.29852 = (long unsigned int) i;
      D.29853 = D.29852 * 8;
      D.29854 = modules + D.29853;
      D.29855 = *D.29854;
      if (D.29855 != 0B) goto <D.29865>; else goto <D.29866>;
      <D.29865>:
      {
        void * * __p;

        D.29867 = (long unsigned int) j;
        __p = mono_array_addr_with_size (res, 8, D.29867);
        D.29852 = (long unsigned int) i;
        D.29853 = D.29852 * 8;
        D.29854 = modules + D.29853;
        D.29855 = *D.29854;
        D.29868 = mono_module_get_object (domain, D.29855);
        mono_gc_wbarrier_set_arrayref (res, __p, D.29868);
      }
      j = j + 1;
      <D.29866>:
      i = i + 1;
      <D.23234>:
      i.127 = (unsigned int) i;
      if (i.127 < module_count) goto <D.23233>; else goto <D.23235>;
      <D.23235>:
      i = 0;
      goto <D.23241>;
      <D.23240>:
      mono_metadata_decode_row (table, i, &cols, 3);
      D.29869 = cols[0];
      if (D.29869 != 0) goto <D.29870>; else goto <D.29871>;
      <D.29870>:
      {
        void * * __p;

        D.29867 = (long unsigned int) j;
        __p = mono_array_addr_with_size (res, 8, D.29867);
        D.29872 = mono_module_file_get_object (domain, image, i);
        mono_gc_wbarrier_set_arrayref (res, __p, D.29872);
      }
      goto <D.29873>;
      <D.29871>:
      {
        struct MonoImage * m;

        D.29874 = i + 1;
        m = mono_image_load_file_for_image (image, D.29874);
        if (m == 0B) goto <D.29875>; else goto <D.29876>;
        <D.29875>:
        {
          struct MonoString * fname;

          D.29877 = mono_domain_get ();
          D.29878 = cols[1];
          D.29879 = mono_metadata_string_heap (image, D.29878);
          fname = mono_string_new (D.29877, D.29879);
          D.29880 = mono_get_exception_file_not_found2 (0B, fname);
          mono_raise_exception (D.29880);
        }
        <D.29876>:
        {
          void * * __p;

          D.29867 = (long unsigned int) j;
          __p = mono_array_addr_with_size (res, 8, D.29867);
          D.29881 = mono_module_get_object (domain, m);
          mono_gc_wbarrier_set_arrayref (res, __p, D.29881);
        }
      }
      <D.29873>:
      i = i + 1;
      j = j + 1;
      <D.23241>:
      if (i < file_count) goto <D.23240>; else goto <D.23242>;
      <D.23242>:
      D.29882 = res;
      return D.29882;
    }
  finally
    {
      cols = {CLOBBER};
    }
}


ves_icall_System_Reflection_Assembly_GetManifestResourceNames (struct MonoReflectionAssembly * assembly)
{
  struct MonoAssembly * D.29885;
  struct MonoImage * D.29886;
  struct MonoVTable * D.29887;
  struct MonoDomain * D.29888;
  struct MonoClass * D.29889;
  <unnamed-unsigned:24> D.29890;
  long unsigned int D.29891;
  unsigned int D.29892;
  long unsigned int D.29893;
  struct MonoString * D.29894;
  int D.29895;
  struct MonoArray * D.29896;
  struct MonoTableInfo * table;
  struct MonoArray * result;
  int i;
  const char * val;

  D.29885 = assembly->assembly;
  D.29886 = D.29885->image;
  table = &D.29886->tables[40];
  D.29887 = MEM[(struct MonoObject *)assembly].vtable;
  D.29888 = D.29887->domain;
  D.29889 = mono_defaults.string_class;
  D.29890 = table->rows;
  D.29891 = (long unsigned int) D.29890;
  result = mono_array_new (D.29888, D.29889, D.29891);
  i = 0;
  goto <D.23087>;
  <D.23086>:
  D.29885 = assembly->assembly;
  D.29886 = D.29885->image;
  D.29892 = mono_metadata_decode_row_col (table, i, 2);
  val = mono_metadata_string_heap (D.29886, D.29892);
  {
    void * * __p;

    D.29893 = (long unsigned int) i;
    __p = mono_array_addr_with_size (result, 8, D.29893);
    D.29887 = MEM[(struct MonoObject *)assembly].vtable;
    D.29888 = D.29887->domain;
    D.29894 = mono_string_new (D.29888, val);
    mono_gc_wbarrier_set_arrayref (result, __p, D.29894);
  }
  i = i + 1;
  <D.23087>:
  D.29890 = table->rows;
  D.29895 = (int) D.29890;
  if (D.29895 > i) goto <D.23086>; else goto <D.23088>;
  <D.23088>:
  D.29896 = result;
  return D.29896;
}


ves_icall_System_Reflection_Assembly_GetManifestResourceInternal (struct MonoReflectionAssembly * assembly, struct MonoString * name, gint32 * size, struct MonoReflectionModule * * ref_module)
{
  struct MonoAssembly * D.29898;
  struct MonoImage * D.29899;
  int i.129;
  unsigned int D.29901;
  int D.23149;
  <unnamed-unsigned:24> D.29903;
  unsigned int D.29904;
  void * D.29907;
  unsigned int D.29910;
  _Bool D.29911;
  long int D.29912;
  long int D.29913;
  int file_idx.130;
  struct MonoDomain * D.29920;
  struct MonoReflectionModule * D.29921;
  unsigned int D.29922;
  char * n;
  struct MonoTableInfo * table;
  guint32 i;
  guint32 cols[4];
  guint32 impl;
  guint32 file_idx;
  const char * val;
  struct MonoImage * module;

  try
    {
      n = mono_string_to_utf8 (name);
      D.29898 = assembly->assembly;
      D.29899 = D.29898->image;
      table = &D.29899->tables[40];
      i = 0;
      goto <D.23152>;
      <D.23151>:
      i.129 = (int) i;
      mono_metadata_decode_row (table, i.129, &cols, 4);
      D.29898 = assembly->assembly;
      D.29899 = D.29898->image;
      D.29901 = cols[2];
      val = mono_metadata_string_heap (D.29899, D.29901);
      {
        size_t __s1_len;
        size_t __s2_len;

        D.23149 = __builtin_strcmp (val, n);
      }
      if (D.23149 == 0) goto <D.23150>; else goto <D.29902>;
      <D.29902>:
      i = i + 1;
      <D.23152>:
      D.29903 = table->rows;
      D.29904 = (unsigned int) D.29903;
      if (D.29904 > i) goto <D.23151>; else goto <D.23150>;
      <D.23150>:
      monoeg_g_free (n);
      D.29903 = table->rows;
      D.29904 = (unsigned int) D.29903;
      if (D.29904 == i) goto <D.29905>; else goto <D.29906>;
      <D.29905>:
      D.29907 = 0B;
      return D.29907;
      <D.29906>:
      impl = cols[3];
      if (impl != 0) goto <D.29908>; else goto <D.29909>;
      <D.29908>:
      D.29910 = impl & 3;
      D.29911 = D.29910 != 0;
      D.29912 = (long int) D.29911;
      D.29913 = __builtin_expect (D.29912, 0);
      if (D.29913 != 0) goto <D.29914>; else goto <D.29915>;
      <D.29914>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "icall.c", 4553, "(impl & MONO_IMPLEMENTATION_MASK) == MONO_IMPLEMENTATION_FILE");
      <D.29915>:
      file_idx = impl >> 2;
      D.29898 = assembly->assembly;
      D.29899 = D.29898->image;
      file_idx.130 = (int) file_idx;
      module = mono_image_load_file_for_image (D.29899, file_idx.130);
      if (module == 0B) goto <D.29917>; else goto <D.29918>;
      <D.29917>:
      D.29907 = 0B;
      return D.29907;
      <D.29918>:
      goto <D.29919>;
      <D.29909>:
      D.29898 = assembly->assembly;
      module = D.29898->image;
      <D.29919>:
      D.29920 = mono_domain_get ();
      D.29921 = mono_module_get_object (D.29920, module);
      mono_gc_wbarrier_generic_store (ref_module, D.29921);
      D.29922 = cols[0];
      D.29907 = mono_image_get_resource (module, D.29922, size);
      return D.29907;
    }
  finally
    {
      cols = {CLOBBER};
    }
}


ves_icall_System_Reflection_Assembly_GetManifestResourceInfoInternal (struct MonoReflectionAssembly * assembly, struct MonoString * name, struct MonoManifestResourceInfo * info)
{
  struct MonoAssembly * D.29925;
  struct MonoImage * D.29926;
  unsigned int D.29927;
  int D.23172;
  <unnamed-unsigned:24> D.29929;
  int D.29930;
  gboolean D.29933;
  unsigned int D.29934;
  unsigned int D.29938;
  unsigned int D.29939;
  int D.29940;
  unsigned int D.29941;
  struct MonoString * * D.29942;
  struct MonoVTable * D.29943;
  struct MonoDomain * D.29944;
  struct MonoString * D.29945;
  unsigned int D.29946;
  struct MonoAssembly * * D.29950;
  long unsigned int D.29951;
  long unsigned int D.29952;
  sizetype D.29953;
  struct MonoAssembly * * D.29954;
  struct MonoAssembly * D.29955;
  char * D.29958;
  struct MonoReflectionAssembly * * D.29959;
  struct MonoDomain * D.29960;
  struct MonoReflectionAssembly * D.29961;
  struct MonoReflectionAssembly * D.29962;
  unsigned int D.29963;
  unsigned int D.29964;
  struct MonoTableInfo * table;
  int i;
  guint32 cols[4];
  guint32 file_cols[3];
  const char * val;
  char * n;

  try
    {
      D.29925 = assembly->assembly;
      D.29926 = D.29925->image;
      table = &D.29926->tables[40];
      n = mono_string_to_utf8 (name);
      i = 0;
      goto <D.23175>;
      <D.23174>:
      mono_metadata_decode_row (table, i, &cols, 4);
      D.29925 = assembly->assembly;
      D.29926 = D.29925->image;
      D.29927 = cols[2];
      val = mono_metadata_string_heap (D.29926, D.29927);
      {
        size_t __s1_len;
        size_t __s2_len;

        D.23172 = __builtin_strcmp (val, n);
      }
      if (D.23172 == 0) goto <D.23173>; else goto <D.29928>;
      <D.29928>:
      i = i + 1;
      <D.23175>:
      D.29929 = table->rows;
      D.29930 = (int) D.29929;
      if (D.29930 > i) goto <D.23174>; else goto <D.23173>;
      <D.23173>:
      monoeg_g_free (n);
      D.29929 = table->rows;
      D.29930 = (int) D.29929;
      if (D.29930 == i) goto <D.29931>; else goto <D.29932>;
      <D.29931>:
      D.29933 = 0;
      return D.29933;
      <D.29932>:
      D.29934 = cols[3];
      if (D.29934 == 0) goto <D.29935>; else goto <D.29936>;
      <D.29935>:
      info->location = 5;
      goto <D.29937>;
      <D.29936>:
      D.29934 = cols[3];
      D.29938 = D.29934 & 3;
      switch (D.29938) <default: <D.29965>, case 0: <D.23176>, case 1: <D.23178>, case 2: <D.23181>>
      <D.23176>:
      D.29934 = cols[3];
      D.29939 = D.29934 >> 2;
      i = (int) D.29939;
      D.29925 = assembly->assembly;
      D.29926 = D.29925->image;
      table = &D.29926->tables[38];
      D.29940 = i + -1;
      mono_metadata_decode_row (table, D.29940, &file_cols, 3);
      D.29925 = assembly->assembly;
      D.29926 = D.29925->image;
      D.29941 = file_cols[1];
      val = mono_metadata_string_heap (D.29926, D.29941);
      D.29942 = &info->filename;
      D.29943 = MEM[(struct MonoObject *)assembly].vtable;
      D.29944 = D.29943->domain;
      D.29945 = mono_string_new (D.29944, val);
      mono_gc_wbarrier_set_field (info, D.29942, D.29945);
      D.29946 = file_cols[0];
      if (D.29946 != 0) goto <D.29947>; else goto <D.29948>;
      <D.29947>:
      info->location = 0;
      goto <D.29949>;
      <D.29948>:
      info->location = 1;
      <D.29949>:
      goto <D.23177>;
      <D.23178>:
      D.29934 = cols[3];
      D.29939 = D.29934 >> 2;
      i = (int) D.29939;
      D.29925 = assembly->assembly;
      D.29926 = D.29925->image;
      D.29940 = i + -1;
      mono_assembly_load_reference (D.29926, D.29940);
      D.29925 = assembly->assembly;
      D.29926 = D.29925->image;
      D.29950 = D.29926->references;
      D.29951 = (long unsigned int) i;
      D.29952 = D.29951 * 8;
      D.29953 = D.29952 + 18446744073709551608;
      D.29954 = D.29950 + D.29953;
      D.29955 = *D.29954;
      if (D.29955 == -1B) goto <D.29956>; else goto <D.29957>;
      <D.29956>:
      {
        char * msg;
        struct MonoException * ex;

        D.29940 = i + -1;
        D.29925 = assembly->assembly;
        D.29926 = D.29925->image;
        D.29958 = D.29926->name;
        msg = monoeg_g_strdup_printf ("Assembly %d referenced from assembly %s not found ", D.29940, D.29958);
        ex = mono_get_exception_file_not_found2 (msg, 0B);
        monoeg_g_free (msg);
        mono_raise_exception (ex);
      }
      <D.29957>:
      D.29959 = &info->assembly;
      D.29960 = mono_domain_get ();
      D.29925 = assembly->assembly;
      D.29926 = D.29925->image;
      D.29950 = D.29926->references;
      D.29951 = (long unsigned int) i;
      D.29952 = D.29951 * 8;
      D.29953 = D.29952 + 18446744073709551608;
      D.29954 = D.29950 + D.29953;
      D.29955 = *D.29954;
      D.29961 = mono_assembly_get_object (D.29960, D.29955);
      mono_gc_wbarrier_set_field (info, D.29959, D.29961);
      D.29962 = info->assembly;
      ves_icall_System_Reflection_Assembly_GetManifestResourceInfoInternal (D.29962, name, info);
      D.29963 = info->location;
      D.29964 = D.29963 | 2;
      info->location = D.29964;
      goto <D.23177>;
      <D.23181>:
      monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "icall.c", 4625);
      <D.29965>:
      <D.23177>:
      <D.29937>:
      D.29933 = 1;
      return D.29933;
    }
  finally
    {
      cols = {CLOBBER};
      file_cols = {CLOBBER};
    }
}


ves_icall_System_Reflection_Assembly_GetManifestModuleInternal (struct MonoReflectionAssembly * assembly)
{
  struct MonoReflectionModule * D.29968;
  struct MonoVTable * D.29969;
  struct MonoDomain * D.29970;
  struct MonoAssembly * D.29971;
  struct MonoImage * D.29972;

  D.29969 = MEM[(struct MonoObject *)assembly].vtable;
  D.29970 = D.29969->domain;
  D.29971 = assembly->assembly;
  D.29972 = D.29971->image;
  D.29968 = mono_module_get_object (D.29970, D.29972);
  return D.29968;
}


ves_icall_System_Reflection_Assembly_GetFilesInternal (struct MonoReflectionAssembly * assembly, struct MonoString * name, MonoBoolean resource_modules)
{
  struct MonoAssembly * D.29974;
  struct MonoImage * D.29975;
  unsigned int D.29978;
  int D.23201;
  char * D.29981;
  struct MonoVTable * D.29982;
  struct MonoDomain * D.29983;
  struct MonoObject * D.29984;
  <unnamed-unsigned:24> D.29985;
  int D.29986;
  unsigned int D.29990;
  unsigned int D.29991;
  struct MonoClass * D.29992;
  long unsigned int D.29993;
  unsigned int D.29997;
  unsigned int D.29998;
  unsigned int D.29999;
  struct MonoString * D.30000;
  struct MonoTableInfo * table;
  struct MonoArray * result;
  int i;
  int count;
  const char * val;
  char * n;

  D.29974 = assembly->assembly;
  D.29975 = D.29974->image;
  table = &D.29975->tables[38];
  result = 0B;
  if (name != 0B) goto <D.29976>; else goto <D.29977>;
  <D.29976>:
  n = mono_string_to_utf8 (name);
  i = 0;
  goto <D.23204>;
  <D.23203>:
  D.29974 = assembly->assembly;
  D.29975 = D.29974->image;
  D.29978 = mono_metadata_decode_row_col (table, i, 1);
  val = mono_metadata_string_heap (D.29975, D.29978);
  {
    size_t __s1_len;
    size_t __s2_len;

    D.23201 = __builtin_strcmp (val, n);
  }
  if (D.23201 == 0) goto <D.29979>; else goto <D.29980>;
  <D.29979>:
  {
    struct MonoString * fn;

    monoeg_g_free (n);
    D.29974 = assembly->assembly;
    D.29981 = D.29974->basedir;
    n = g_concat_dir_and_file (D.29981, val);
    D.29982 = MEM[(struct MonoObject *)assembly].vtable;
    D.29983 = D.29982->domain;
    fn = mono_string_new (D.29983, n);
    monoeg_g_free (n);
    D.29984 = fn;
    return D.29984;
  }
  <D.29980>:
  i = i + 1;
  <D.23204>:
  D.29985 = table->rows;
  D.29986 = (int) D.29985;
  if (D.29986 > i) goto <D.23203>; else goto <D.23205>;
  <D.23205>:
  monoeg_g_free (n);
  D.29984 = 0B;
  return D.29984;
  <D.29977>:
  count = 0;
  i = 0;
  goto <D.23207>;
  <D.23206>:
  if (resource_modules != 0) goto <D.29987>; else goto <D.29989>;
  <D.29989>:
  D.29990 = mono_metadata_decode_row_col (table, i, 0);
  D.29991 = D.29990 & 1;
  if (D.29991 == 0) goto <D.29987>; else goto <D.29988>;
  <D.29987>:
  count = count + 1;
  <D.29988>:
  i = i + 1;
  <D.23207>:
  D.29985 = table->rows;
  D.29986 = (int) D.29985;
  if (D.29986 > i) goto <D.23206>; else goto <D.23208>;
  <D.23208>:
  D.29982 = MEM[(struct MonoObject *)assembly].vtable;
  D.29983 = D.29982->domain;
  D.29992 = mono_defaults.string_class;
  D.29993 = (long unsigned int) count;
  result = mono_array_new (D.29983, D.29992, D.29993);
  count = 0;
  i = 0;
  goto <D.23211>;
  <D.23210>:
  if (resource_modules != 0) goto <D.29994>; else goto <D.29996>;
  <D.29996>:
  D.29997 = mono_metadata_decode_row_col (table, i, 0);
  D.29998 = D.29997 & 1;
  if (D.29998 == 0) goto <D.29994>; else goto <D.29995>;
  <D.29994>:
  D.29974 = assembly->assembly;
  D.29975 = D.29974->image;
  D.29999 = mono_metadata_decode_row_col (table, i, 1);
  val = mono_metadata_string_heap (D.29975, D.29999);
  D.29974 = assembly->assembly;
  D.29981 = D.29974->basedir;
  n = g_concat_dir_and_file (D.29981, val);
  {
    void * * __p;

    D.29993 = (long unsigned int) count;
    __p = mono_array_addr_with_size (result, 8, D.29993);
    D.29982 = MEM[(struct MonoObject *)assembly].vtable;
    D.29983 = D.29982->domain;
    D.30000 = mono_string_new (D.29983, n);
    mono_gc_wbarrier_set_arrayref (result, __p, D.30000);
  }
  monoeg_g_free (n);
  count = count + 1;
  <D.29995>:
  i = i + 1;
  <D.23211>:
  D.29985 = table->rows;
  D.29986 = (int) D.29985;
  if (D.29986 > i) goto <D.23210>; else goto <D.23212>;
  <D.23212>:
  D.29984 = result;
  return D.29984;
}


g_concat_dir_and_file (const char * dir, const char * file)
{
  char * D.30004;
  long unsigned int D.30007;
  sizetype D.30008;
  const char * D.30009;
  char D.30010;

  if (dir == 0B) goto <D.30002>; else goto <D.30003>;
  <D.30002>:
  monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "icall.c", 4511, "dir != NULL");
  D.30004 = 0B;
  return D.30004;
  <D.30003>:
  if (file == 0B) goto <D.30005>; else goto <D.30006>;
  <D.30005>:
  monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "icall.c", 4512, "file != NULL");
  D.30004 = 0B;
  return D.30004;
  <D.30006>:
  D.30007 = strlen (dir);
  D.30008 = D.30007 + 18446744073709551615;
  D.30009 = dir + D.30008;
  D.30010 = *D.30009;
  if (D.30010 != 47) goto <D.30011>; else goto <D.30012>;
  <D.30011>:
  D.30004 = monoeg_g_strconcat (dir, "/", file, 0B);
  return D.30004;
  <D.30012>:
  D.30004 = monoeg_g_strconcat (dir, file, 0B);
  return D.30004;
}


ves_icall_System_Reflection_Assembly_GetExecutingAssembly ()
{
  struct MonoMethod * dest.131;
  _Bool D.30015;
  long int D.30016;
  long int D.30017;
  struct MonoReflectionAssembly * D.30020;
  struct MonoDomain * D.30021;
  struct MonoClass * D.30022;
  struct MonoImage * D.30023;
  struct MonoAssembly * D.30024;
  struct MonoMethod * dest;

  try
    {
      dest = 0B;
      mono_stack_walk_no_il (get_executing, &dest);
      dest.131 = dest;
      D.30015 = dest.131 == 0B;
      D.30016 = (long int) D.30015;
      D.30017 = __builtin_expect (D.30016, 0);
      if (D.30017 != 0) goto <D.30018>; else goto <D.30019>;
      <D.30018>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "icall.c", 4821, "dest");
      <D.30019>:
      D.30021 = mono_domain_get ();
      dest.131 = dest;
      D.30022 = dest.131->klass;
      D.30023 = D.30022->image;
      D.30024 = D.30023->assembly;
      D.30020 = mono_assembly_get_object (D.30021, D.30024);
      return D.30020;
    }
  finally
    {
      dest = {CLOBBER};
    }
}


get_executing (struct MonoMethod * m, gint32 no, gint32 ilo, gboolean managed, void * data)
{
  gboolean D.30029;
  struct MonoMethod * D.30030;
  int D.21742;
  int iftmp.132;
  int D.21741;
  struct MonoClass * D.30036;
  const char[18] * D.30037;
  unsigned char D.30038;
  int D.30039;
  unsigned char D.30040;
  int D.30041;
  const unsigned char * D.30046;
  unsigned char D.30047;
  int D.30048;
  const unsigned char * D.30049;
  unsigned char D.30050;
  int D.30051;
  const unsigned char * D.30056;
  unsigned char D.30057;
  int D.30058;
  const unsigned char * D.30059;
  unsigned char D.30060;
  int D.30061;
  const unsigned char * D.30066;
  unsigned char D.30067;
  int D.30068;
  const unsigned char * D.30069;
  unsigned char D.30070;
  int D.30071;
  const char * D.30073;
  struct MonoMethod * * dest;

  dest = data;
  if (managed == 0) goto <D.30027>; else goto <D.30028>;
  <D.30027>:
  D.30029 = 0;
  return D.30029;
  <D.30028>:
  D.30030 = *dest;
  if (D.30030 == 0B) goto <D.30031>; else goto <D.30032>;
  <D.30031>:
  {
    size_t __s1_len;
    size_t __s2_len;

    __s2_len = 17;
    if (__s2_len <= 3) goto <D.30034>; else goto <D.30035>;
    <D.30034>:
    {
      const unsigned char * __s2;
      int __result;

      D.30036 = m->klass;
      __s2 = D.30036->name_space;
      D.30037 = "System.Reflection";
      D.30038 = MEM[(const unsigned char *)D.30037];
      D.30039 = (int) D.30038;
      D.30040 = *__s2;
      D.30041 = (int) D.30040;
      __result = D.30039 - D.30041;
      {
        if (__s2_len != 0) goto <D.30042>; else goto <D.30043>;
        <D.30042>:
        if (__result == 0) goto <D.30044>; else goto <D.30045>;
        <D.30044>:
        D.30046 = &MEM[(void *)"System.Reflection" + 1B];
        D.30047 = *D.30046;
        D.30048 = (int) D.30047;
        D.30049 = __s2 + 1;
        D.30050 = *D.30049;
        D.30051 = (int) D.30050;
        __result = D.30048 - D.30051;
        if (__s2_len > 1) goto <D.30052>; else goto <D.30053>;
        <D.30052>:
        if (__result == 0) goto <D.30054>; else goto <D.30055>;
        <D.30054>:
        D.30056 = &MEM[(void *)"System.Reflection" + 2B];
        D.30057 = *D.30056;
        D.30058 = (int) D.30057;
        D.30059 = __s2 + 2;
        D.30060 = *D.30059;
        D.30061 = (int) D.30060;
        __result = D.30058 - D.30061;
        if (__s2_len > 2) goto <D.30062>; else goto <D.30063>;
        <D.30062>:
        if (__result == 0) goto <D.30064>; else goto <D.30065>;
        <D.30064>:
        D.30066 = &MEM[(void *)"System.Reflection" + 3B];
        D.30067 = *D.30066;
        D.30068 = (int) D.30067;
        D.30069 = __s2 + 3;
        D.30070 = *D.30069;
        D.30071 = (int) D.30070;
        __result = D.30068 - D.30071;
        <D.30065>:
        <D.30063>:
        <D.30055>:
        <D.30053>:
        <D.30045>:
        <D.30043>:
      }
      D.21741 = __result;
    }
    iftmp.132 = -D.21741;
    goto <D.30072>;
    <D.30035>:
    D.30036 = m->klass;
    D.30073 = D.30036->name_space;
    iftmp.132 = __builtin_strcmp (D.30073, "System.Reflection");
    <D.30072>:
    D.21742 = iftmp.132;
  }
  if (D.21742 == 0) goto <D.30074>; else goto <D.30075>;
  <D.30074>:
  D.30029 = 0;
  return D.30029;
  <D.30075>:
  *dest = m;
  D.30029 = 1;
  return D.30029;
  <D.30032>:
  D.30029 = 0;
  return D.30029;
}


ves_icall_System_Reflection_Assembly_GetEntryAssembly ()
{
  struct MonoAssembly * D.30077;
  struct MonoReflectionAssembly * D.30080;
  struct MonoDomain * domain;

  domain = mono_domain_get ();
  D.30077 = domain->entry_assembly;
  if (D.30077 == 0B) goto <D.30078>; else goto <D.30079>;
  <D.30078>:
  D.30080 = 0B;
  return D.30080;
  <D.30079>:
  D.30077 = domain->entry_assembly;
  D.30080 = mono_assembly_get_object (domain, D.30077);
  return D.30080;
}


ves_icall_System_Reflection_Assembly_GetCallingAssembly ()
{
  struct MonoMethod * dest.133;
  struct MonoReflectionAssembly * D.30085;
  struct MonoDomain * D.30086;
  struct MonoClass * D.30087;
  struct MonoImage * D.30088;
  struct MonoAssembly * D.30089;
  struct MonoMethod * m;
  struct MonoMethod * dest;

  try
    {
      dest = 0B;
      mono_stack_walk_no_il (get_executing, &dest);
      m = dest;
      mono_stack_walk_no_il (get_caller, &dest);
      dest.133 = dest;
      if (dest.133 == 0B) goto <D.30083>; else goto <D.30084>;
      <D.30083>:
      dest = m;
      <D.30084>:
      D.30086 = mono_domain_get ();
      dest.133 = dest;
      D.30087 = dest.133->klass;
      D.30088 = D.30087->image;
      D.30089 = D.30088->assembly;
      D.30085 = mono_assembly_get_object (D.30086, D.30089);
      return D.30085;
    }
  finally
    {
      dest = {CLOBBER};
    }
}


get_caller (struct MonoMethod * m, gint32 no, gint32 ilo, gboolean managed, void * data)
{
  gboolean D.30094;
  struct MonoMethod * D.30095;
  struct MonoMethod * * dest;

  dest = data;
  if (managed == 0) goto <D.30092>; else goto <D.30093>;
  <D.30092>:
  D.30094 = 0;
  return D.30094;
  <D.30093>:
  D.30095 = *dest;
  if (D.30095 == m) goto <D.30096>; else goto <D.30097>;
  <D.30096>:
  *dest = 0B;
  D.30094 = 0;
  return D.30094;
  <D.30097>:
  D.30095 = *dest;
  if (D.30095 == 0B) goto <D.30098>; else goto <D.30099>;
  <D.30098>:
  *dest = m;
  D.30094 = 1;
  return D.30094;
  <D.30099>:
  D.30094 = 0;
  return D.30094;
}


ves_icall_System_Reflection_Assembly_FillName (struct MonoReflectionAssembly * assembly, struct MonoReflectionAssemblyName * aname)
{
  struct MonoImage * D.30101;
  char * D.30102;
  int D.30103;
  struct MonoVTable * D.30106;
  struct MonoDomain * D.30107;
  struct MonoAssemblyName * D.30108;
  char * D.30109;
  gchar * absolute;
  struct MonoAssembly * mass;

  mass = assembly->assembly;
  D.30101 = mass->image;
  D.30102 = D.30101->name;
  D.30103 = monoeg_g_path_is_absolute (D.30102);
  if (D.30103 != 0) goto <D.30104>; else goto <D.30105>;
  <D.30104>:
  D.30106 = MEM[(struct MonoObject *)assembly].vtable;
  D.30107 = D.30106->domain;
  D.30108 = &mass->aname;
  D.30101 = mass->image;
  D.30102 = D.30101->name;
  fill_reflection_assembly_name (D.30107, aname, D.30108, D.30102, 1, 1, 1);
  return;
  <D.30105>:
  D.30109 = mass->basedir;
  D.30101 = mass->image;
  D.30102 = D.30101->name;
  absolute = monoeg_g_build_path ("/", D.30109, D.30102, 0B);
  D.30106 = MEM[(struct MonoObject *)assembly].vtable;
  D.30107 = D.30106->domain;
  D.30108 = &mass->aname;
  fill_reflection_assembly_name (D.30107, aname, D.30108, absolute, 1, 1, 1);
  monoeg_g_free (absolute);
}


ves_icall_System_Object_obj_address (struct MonoObject * this)
{
  void * D.30111;

  D.30111 = this;
  return D.30111;
}


ves_icall_System_Object_MemberwiseClone (struct MonoObject * this)
{
  struct MonoObject * D.30113;

  D.30113 = mono_object_clone (this);
  return D.30113;
}


ves_icall_System_Object_GetType (struct MonoObject * obj)
{
  struct MonoVTable * D.30115;
  struct MonoClass * D.30116;
  struct MonoClass * D.30117;
  struct MonoReflectionType * D.30120;
  struct MonoDomain * D.30121;
  struct MonoRemoteClass * D.30122;
  struct MonoClass * D.30123;
  struct MonoType * D.30124;
  struct MonoType * D.30125;

  D.30115 = obj->vtable;
  D.30116 = D.30115->klass;
  D.30117 = mono_defaults.transparent_proxy_class;
  if (D.30116 == D.30117) goto <D.30118>; else goto <D.30119>;
  <D.30118>:
  D.30115 = obj->vtable;
  D.30121 = D.30115->domain;
  D.30122 = MEM[(struct MonoTransparentProxy *)obj].remote_class;
  D.30123 = D.30122->proxy_class;
  D.30124 = &D.30123->byval_arg;
  D.30120 = mono_type_get_object (D.30121, D.30124);
  return D.30120;
  <D.30119>:
  D.30115 = obj->vtable;
  D.30121 = D.30115->domain;
  D.30115 = obj->vtable;
  D.30116 = D.30115->klass;
  D.30125 = &D.30116->byval_arg;
  D.30120 = mono_type_get_object (D.30121, D.30125);
  return D.30120;
}


ves_icall_System_NumberFormatter_GetFormatterTables (const guint64 * * mantissas, const gint32 * * exponents, const gunichar2 * * digitLowerTable, const gunichar2 * * digitUpperTable, const gint64 * * tenPowersList, const gint32 * * decHexDigits)
{
  *mantissas = &Formatter_MantissaBitsTable;
  *exponents = &Formatter_TensExponentTable;
  *digitLowerTable = &Formatter_DigitLowerTable;
  *digitUpperTable = &Formatter_DigitUpperTable;
  *tenPowersList = &Formatter_TenPowersList;
  *decHexDigits = &Formatter_DecHexDigits;
}


mono_type_type_from_obj (struct MonoReflectionType * mtype, struct MonoObject * obj)
{
  struct MonoVTable * D.30127;
  struct MonoClass * D.30128;
  struct MonoType * D.30129;
  struct MonoType * D.30130;
  unsigned char D.30131;
  _Bool D.30132;
  long int D.30133;
  long int D.30134;

  D.30127 = obj->vtable;
  D.30128 = D.30127->klass;
  D.30129 = &D.30128->byval_arg;
  mtype->type = D.30129;
  D.30130 = mtype->type;
  D.30131 = D.30130->type;
  D.30132 = D.30131 == 0;
  D.30133 = (long int) D.30132;
  D.30134 = __builtin_expect (D.30133, 0);
  if (D.30134 != 0) goto <D.30135>; else goto <D.30136>;
  <D.30135>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "icall.c", 1149, "mtype->type->type");
  <D.30136>:
}


vell_icall_MonoType_get_core_clr_security_level (struct MonoReflectionType * this)
{
  struct MonoType * D.30137;
  int D.30138;
  <unnamed type> D.30139;
  struct MonoClass * klass;

  D.30137 = this->type;
  klass = mono_class_from_mono_type (D.30137);
  mono_class_init_or_throw (klass);
  D.30139 = mono_security_core_clr_class_level (klass);
  D.30138 = (int) D.30139;
  return D.30138;
}


ves_icall_get_attributes (struct MonoReflectionType * type)
{
  struct MonoType * D.30141;
  guint32 D.30142;
  struct MonoClass * klass;

  D.30141 = type->type;
  klass = mono_class_from_mono_type (D.30141);
  D.30142 = klass->flags;
  return D.30142;
}


ves_icall_MonoType_get_Namespace (struct MonoReflectionType * type)
{
  struct MonoType * D.30144;
  struct MonoClass * D.30145;
  const char * D.30146;
  char D.30147;
  struct MonoString * D.30150;
  struct MonoDomain * domain;
  struct MonoClass * class;

  domain = mono_domain_get ();
  D.30144 = type->type;
  class = mono_class_from_mono_type (D.30144);
  goto <D.22212>;
  <D.22211>:
  class = class->nested_in;
  <D.22212>:
  D.30145 = class->nested_in;
  if (D.30145 != 0B) goto <D.22211>; else goto <D.22213>;
  <D.22213>:
  D.30146 = class->name_space;
  D.30147 = *D.30146;
  if (D.30147 == 0) goto <D.30148>; else goto <D.30149>;
  <D.30148>:
  D.30150 = 0B;
  return D.30150;
  <D.30149>:
  D.30146 = class->name_space;
  D.30150 = mono_string_new (domain, D.30146);
  return D.30150;
}


ves_icall_MonoType_get_Name (struct MonoReflectionType * type)
{
  struct MonoType * D.30152;
  long unsigned int D.30153;
  long unsigned int D.30154;
  const char * D.30157;
  struct MonoString * D.30158;
  struct MonoDomain * domain;
  struct MonoClass * class;

  domain = mono_domain_get ();
  D.30152 = type->type;
  class = mono_class_from_mono_type (D.30152);
  D.30152 = type->type;
  D.30153 = BIT_FIELD_REF <*D.30152, 64, 64>;
  D.30154 = D.30153 & 1073741824;
  if (D.30154 != 0) goto <D.30155>; else goto <D.30156>;
  <D.30155>:
  {
    char * n;
    struct MonoString * res;

    D.30157 = class->name;
    n = monoeg_g_strdup_printf ("%s&", D.30157);
    res = mono_string_new (domain, n);
    monoeg_g_free (n);
    D.30158 = res;
    return D.30158;
  }
  <D.30156>:
  D.30157 = class->name;
  D.30158 = mono_string_new (domain, D.30157);
  return D.30158;
}


ves_icall_MonoType_get_Module (struct MonoReflectionType * type)
{
  struct MonoType * D.30160;
  struct MonoReflectionModule * D.30161;
  struct MonoVTable * D.30162;
  struct MonoDomain * D.30163;
  struct MonoImage * D.30164;
  struct MonoClass * class;

  D.30160 = type->type;
  class = mono_class_from_mono_type (D.30160);
  D.30162 = MEM[(struct MonoObject *)type].vtable;
  D.30163 = D.30162->domain;
  D.30164 = class->image;
  D.30161 = mono_module_get_object (D.30163, D.30164);
  return D.30161;
}


ves_icall_MonoType_get_IsGenericParameter (struct MonoReflectionType * type)
{
  MonoBoolean D.30166;
  struct MonoType * D.30167;

  D.30167 = type->type;
  D.30166 = is_generic_parameter (D.30167);
  return D.30166;
}


ves_icall_MonoType_get_DeclaringType (struct MonoReflectionType * type)
{
  struct MonoType * D.30169;
  long unsigned int D.30170;
  long unsigned int D.30171;
  struct MonoReflectionType * D.30174;
  unsigned char D.30175;
  struct MonoGenericParam * D.30178;
  struct MonoGenericContainer * D.30179;
  struct MonoMethod * D.30183;
  struct MonoClass * D.30185;
  struct MonoReflectionType * iftmp.134;
  struct MonoType * D.30189;
  struct MonoDomain * domain;
  struct MonoClass * class;

  domain = mono_domain_get ();
  D.30169 = type->type;
  D.30170 = BIT_FIELD_REF <*D.30169, 64, 64>;
  D.30171 = D.30170 & 1073741824;
  if (D.30171 != 0) goto <D.30172>; else goto <D.30173>;
  <D.30172>:
  D.30174 = 0B;
  return D.30174;
  <D.30173>:
  D.30169 = type->type;
  D.30175 = D.30169->type;
  if (D.30175 == 19) goto <D.30176>; else goto <D.30177>;
  <D.30176>:
  D.30169 = type->type;
  D.30178 = D.30169->data.generic_param;
  D.30179 = D.30178->owner;
  class = D.30179->owner.klass;
  goto <D.30180>;
  <D.30177>:
  D.30169 = type->type;
  D.30175 = D.30169->type;
  if (D.30175 == 30) goto <D.30181>; else goto <D.30182>;
  <D.30181>:
  D.30169 = type->type;
  D.30178 = D.30169->data.generic_param;
  D.30179 = D.30178->owner;
  D.30183 = D.30179->owner.method;
  class = D.30183->klass;
  goto <D.30184>;
  <D.30182>:
  D.30169 = type->type;
  D.30185 = mono_class_from_mono_type (D.30169);
  class = D.30185->nested_in;
  <D.30184>:
  <D.30180>:
  if (class != 0B) goto <D.30187>; else goto <D.30188>;
  <D.30187>:
  D.30189 = &class->byval_arg;
  iftmp.134 = mono_type_get_object (domain, D.30189);
  goto <D.30190>;
  <D.30188>:
  iftmp.134 = 0B;
  <D.30190>:
  D.30174 = iftmp.134;
  return D.30174;
}


ves_icall_MonoType_get_DeclaringMethod (struct MonoReflectionType * ref_type)
{
  long unsigned int D.30194;
  long unsigned int D.30195;
  unsigned char D.30197;
  struct MonoException * D.30199;
  struct MonoReflectionMethod * D.30202;
  struct MonoGenericParam * D.30203;
  struct MonoGenericContainer * D.30204;
  _Bool D.30205;
  long int D.30206;
  long int D.30207;
  struct MonoVTable * D.30210;
  struct MonoDomain * D.30211;
  struct MonoClass * D.30212;
  struct MonoMethod * method;
  struct MonoType * type;

  type = ref_type->type;
  D.30194 = BIT_FIELD_REF <*type, 64, 64>;
  D.30195 = D.30194 & 1073741824;
  if (D.30195 != 0) goto <D.30192>; else goto <D.30196>;
  <D.30196>:
  D.30197 = type->type;
  if (D.30197 != 30) goto <D.30198>; else goto <D.30193>;
  <D.30198>:
  D.30197 = type->type;
  if (D.30197 != 19) goto <D.30192>; else goto <D.30193>;
  <D.30192>:
  D.30199 = mono_get_exception_invalid_operation ("DeclaringMethod can only be used on generic arguments");
  mono_raise_exception (D.30199);
  <D.30193>:
  D.30197 = type->type;
  if (D.30197 == 19) goto <D.30200>; else goto <D.30201>;
  <D.30200>:
  D.30202 = 0B;
  return D.30202;
  <D.30201>:
  D.30203 = type->data.generic_param;
  D.30204 = D.30203->owner;
  method = D.30204->owner.method;
  D.30205 = method == 0B;
  D.30206 = (long int) D.30205;
  D.30207 = __builtin_expect (D.30206, 0);
  if (D.30207 != 0) goto <D.30208>; else goto <D.30209>;
  <D.30208>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "icall.c", 2570, "method");
  <D.30209>:
  D.30210 = MEM[(struct MonoObject *)ref_type].vtable;
  D.30211 = D.30210->domain;
  D.30212 = method->klass;
  D.30202 = mono_method_get_object (D.30211, method, D.30212);
  return D.30202;
}


ves_icall_get_type_parent (struct MonoReflectionType * type)
{
  struct MonoType * D.30214;
  struct MonoReflectionType * D.30215;
  struct MonoReflectionType * iftmp.135;
  struct MonoClass * D.30217;
  struct MonoVTable * D.30220;
  struct MonoDomain * D.30221;
  struct MonoType * D.30222;
  struct MonoClass * class;

  D.30214 = type->type;
  class = mono_class_from_mono_type (D.30214);
  D.30217 = class->parent;
  if (D.30217 != 0B) goto <D.30218>; else goto <D.30219>;
  <D.30218>:
  D.30220 = MEM[(struct MonoObject *)type].vtable;
  D.30221 = D.30220->domain;
  D.30217 = class->parent;
  D.30222 = &D.30217->byval_arg;
  iftmp.135 = mono_type_get_object (D.30221, D.30222);
  goto <D.30223>;
  <D.30219>:
  iftmp.135 = 0B;
  <D.30223>:
  D.30215 = iftmp.135;
  return D.30215;
}


ves_icall_MonoType_get_Assembly (struct MonoReflectionType * type)
{
  struct MonoType * D.30225;
  struct MonoReflectionAssembly * D.30226;
  struct MonoImage * D.30227;
  struct MonoAssembly * D.30228;
  struct MonoDomain * domain;
  struct MonoClass * class;

  domain = mono_domain_get ();
  D.30225 = type->type;
  class = mono_class_from_mono_type (D.30225);
  D.30227 = class->image;
  D.30228 = D.30227->assembly;
  D.30226 = mono_assembly_get_object (domain, D.30228);
  return D.30226;
}


ves_icall_System_MonoType_getFullName (struct MonoReflectionType * object, gboolean full_name, gboolean assembly_qualified)
{
  struct MonoVTable * D.30230;
  MonoTypeNameFormat iftmp.136;
  struct MonoType * D.30238;
  struct MonoString * D.30241;
  unsigned char D.30246;
  struct MonoDomain * domain;
  MonoTypeNameFormat format;
  struct MonoString * res;
  gchar * name;

  D.30230 = MEM[(struct MonoObject *)object].vtable;
  domain = D.30230->domain;
  if (full_name != 0) goto <D.30231>; else goto <D.30232>;
  <D.30231>:
  if (assembly_qualified != 0) goto <D.30234>; else goto <D.30235>;
  <D.30234>:
  iftmp.136 = 3;
  goto <D.30236>;
  <D.30235>:
  iftmp.136 = 2;
  <D.30236>:
  format = iftmp.136;
  goto <D.30237>;
  <D.30232>:
  format = 1;
  <D.30237>:
  D.30238 = object->type;
  name = mono_type_get_name_full (D.30238, format);
  if (name == 0B) goto <D.30239>; else goto <D.30240>;
  <D.30239>:
  D.30241 = 0B;
  return D.30241;
  <D.30240>:
  if (full_name != 0) goto <D.30244>; else goto <D.30245>;
  <D.30244>:
  D.30238 = object->type;
  D.30246 = D.30238->type;
  if (D.30246 == 19) goto <D.30242>; else goto <D.30247>;
  <D.30247>:
  D.30238 = object->type;
  D.30246 = D.30238->type;
  if (D.30246 == 30) goto <D.30242>; else goto <D.30243>;
  <D.30242>:
  monoeg_g_free (name);
  D.30241 = 0B;
  return D.30241;
  <D.30243>:
  <D.30245>:
  res = mono_string_new (domain, name);
  monoeg_g_free (name);
  D.30241 = res;
  return D.30241;
}


ves_icall_type_isprimitive (struct MonoReflectionType * type)
{
  MonoBoolean D.30249;
  int iftmp.137;
  struct MonoType * D.30254;
  long unsigned int D.30255;
  long unsigned int D.30256;
  unsigned char D.30258;
  unsigned char D.30259;

  D.30254 = type->type;
  D.30255 = BIT_FIELD_REF <*D.30254, 64, 64>;
  D.30256 = D.30255 & 1073741824;
  if (D.30256 == 0) goto <D.30257>; else goto <D.30251>;
  <D.30257>:
  D.30254 = type->type;
  D.30258 = D.30254->type;
  D.30259 = D.30258 + 254;
  if (D.30259 <= 11) goto <D.30252>; else goto <D.30260>;
  <D.30260>:
  D.30254 = type->type;
  D.30258 = D.30254->type;
  if (D.30258 == 24) goto <D.30252>; else goto <D.30261>;
  <D.30261>:
  D.30254 = type->type;
  D.30258 = D.30254->type;
  if (D.30258 == 25) goto <D.30252>; else goto <D.30251>;
  <D.30252>:
  iftmp.137 = 1;
  goto <D.30253>;
  <D.30251>:
  iftmp.137 = 0;
  <D.30253>:
  D.30249 = (MonoBoolean) iftmp.137;
  return D.30249;
}


ves_icall_type_ispointer (struct MonoReflectionType * type)
{
  MonoBoolean D.30263;
  struct MonoType * D.30264;
  unsigned char D.30265;
  _Bool D.30266;

  D.30264 = type->type;
  D.30265 = D.30264->type;
  D.30266 = D.30265 == 15;
  D.30263 = (MonoBoolean) D.30266;
  return D.30263;
}


ves_icall_type_iscomobject (struct MonoReflectionType * type)
{
  struct MonoType * D.30268;
  MonoBoolean D.30269;
  <unnamed-unsigned:1> D.30270;
  struct MonoClass * klass;

  D.30268 = type->type;
  klass = mono_class_from_mono_type (D.30268);
  mono_class_init_or_throw (klass);
  D.30270 = klass->is_com_object;
  D.30269 = (MonoBoolean) D.30270;
  return D.30269;
}


ves_icall_type_isbyref (struct MonoReflectionType * type)
{
  MonoBoolean D.30272;
  struct MonoType * D.30273;
  <unnamed-unsigned:1> D.30274;

  D.30273 = type->type;
  D.30274 = D.30273->byref;
  D.30272 = (MonoBoolean) D.30274;
  return D.30272;
}


ves_icall_MonoType_GetEvent (struct MonoReflectionType * type, struct MonoString * name, guint32 bflags)
{
  struct MonoType * D.30276;
  long unsigned int D.30277;
  long unsigned int D.30278;
  struct MonoReflectionEvent * D.30281;
  struct MonoVTable * D.30282;
  int (*<T3a56>) (const char *, const char *) iftmp.138;
  unsigned int D.30284;
  unsigned char D.30288;
  struct MonoException * D.30291;
  const char * D.30292;
  int D.30293;
  short unsigned int D.30302;
  int D.30303;
  int D.30304;
  unsigned int D.30307;
  unsigned int D.30311;
  int D.30318;
  unsigned int D.30321;
  unsigned int D.30324;
  unsigned int D.30330;
  unsigned int D.30336;
  struct MonoDomain * domain;
  struct MonoClass * klass;
  struct MonoClass * startklass;
  void * iter;
  struct MonoEvent * event;
  struct MonoMethod * method;
  gchar * event_name;
  int (*<T3a56>) (const char *, const char *) compare_func;
  void handle_parent = <<< error >>>;

  try
    {
      event_name = mono_string_to_utf8 (name);
      D.30276 = type->type;
      D.30277 = BIT_FIELD_REF <*D.30276, 64, 64>;
      D.30278 = D.30277 & 1073741824;
      if (D.30278 != 0) goto <D.30279>; else goto <D.30280>;
      <D.30279>:
      D.30281 = 0B;
      return D.30281;
      <D.30280>:
      D.30276 = type->type;
      startklass = mono_class_from_mono_type (D.30276);
      klass = startklass;
      D.30282 = MEM[(struct MonoObject *)type].vtable;
      domain = D.30282->domain;
      mono_class_init_or_throw (klass);
      D.30284 = bflags & 1;
      if (D.30284 != 0) goto <D.30285>; else goto <D.30286>;
      <D.30285>:
      iftmp.138 = monoeg_ascii_strcasecmp;
      goto <D.30287>;
      <D.30286>:
      iftmp.138 = strcmp;
      <D.30287>:
      compare_func = iftmp.138;
      handle_parent:
      D.30288 = klass->exception_type;
      if (D.30288 != 0) goto <D.30289>; else goto <D.30290>;
      <D.30289>:
      D.30291 = mono_class_get_exception_for_failure (klass);
      mono_raise_exception (D.30291);
      <D.30290>:
      iter = 0B;
      goto <D.22924>;
      <D.22925>:
      D.30292 = event->name;
      D.30293 = compare_func (D.30292, event_name);
      if (D.30293 != 0) goto <D.30294>; else goto <D.30295>;
      <D.30294>:
      // predicted unlikely by continue predictor.
      goto <D.22924>;
      <D.30295>:
      method = event->add;
      if (method == 0B) goto <D.30296>; else goto <D.30297>;
      <D.30296>:
      method = event->remove;
      <D.30297>:
      if (method == 0B) goto <D.30298>; else goto <D.30299>;
      <D.30298>:
      method = event->raise;
      <D.30299>:
      if (method != 0B) goto <D.30300>; else goto <D.30301>;
      <D.30300>:
      D.30302 = method->flags;
      D.30303 = (int) D.30302;
      D.30304 = D.30303 & 7;
      if (D.30304 == 6) goto <D.30305>; else goto <D.30306>;
      <D.30305>:
      D.30307 = bflags & 16;
      if (D.30307 == 0) goto <D.30308>; else goto <D.30309>;
      <D.30308>:
      // predicted unlikely by continue predictor.
      goto <D.22924>;
      <D.30309>:
      goto <D.30310>;
      <D.30306>:
      D.30311 = bflags & 32;
      if (D.30311 == 0) goto <D.30312>; else goto <D.30313>;
      <D.30312>:
      // predicted unlikely by continue predictor.
      goto <D.22924>;
      <D.30313>:
      if (klass != startklass) goto <D.30314>; else goto <D.30315>;
      <D.30314>:
      D.30302 = method->flags;
      D.30303 = (int) D.30302;
      D.30304 = D.30303 & 7;
      if (D.30304 == 1) goto <D.30316>; else goto <D.30317>;
      <D.30316>:
      // predicted unlikely by continue predictor.
      goto <D.22924>;
      <D.30317>:
      <D.30315>:
      <D.30310>:
      D.30302 = method->flags;
      D.30303 = (int) D.30302;
      D.30318 = D.30303 & 16;
      if (D.30318 != 0) goto <D.30319>; else goto <D.30320>;
      <D.30319>:
      D.30321 = bflags & 8;
      if (D.30321 == 0) goto <D.30322>; else goto <D.30323>;
      <D.30322>:
      // predicted unlikely by continue predictor.
      goto <D.22924>;
      <D.30323>:
      D.30324 = bflags & 64;
      if (D.30324 == 0) goto <D.30325>; else goto <D.30326>;
      <D.30325>:
      if (klass != startklass) goto <D.30327>; else goto <D.30328>;
      <D.30327>:
      // predicted unlikely by continue predictor.
      goto <D.22924>;
      <D.30328>:
      <D.30326>:
      goto <D.30329>;
      <D.30320>:
      D.30330 = bflags & 4;
      if (D.30330 == 0) goto <D.30331>; else goto <D.30332>;
      <D.30331>:
      // predicted unlikely by continue predictor.
      goto <D.22924>;
      <D.30332>:
      <D.30329>:
      goto <D.30333>;
      <D.30301>:
      D.30311 = bflags & 32;
      if (D.30311 == 0) goto <D.30334>; else goto <D.30335>;
      <D.30334>:
      // predicted unlikely by continue predictor.
      goto <D.22924>;
      <D.30335>:
      <D.30333>:
      monoeg_g_free (event_name);
      D.30281 = mono_event_get_object (domain, startklass, event);
      return D.30281;
      <D.22924>:
      event = mono_class_get_events (klass, &iter);
      if (event != 0B) goto <D.22925>; else goto <D.22926>;
      <D.22926>:
      D.30336 = bflags & 2;
      if (D.30336 == 0) goto <D.30337>; else goto <D.30338>;
      <D.30337>:
      klass = klass->parent;
      if (klass != 0B) goto handle_parent; else goto <D.30339>;
      <D.30339>:
      <D.30338>:
      monoeg_g_free (event_name);
      D.30281 = 0B;
      return D.30281;
    }
  finally
    {
      iter = {CLOBBER};
    }
}


ves_icall_Type_GetPropertiesByName (struct MonoReflectionType * type, struct MonoString * name, guint32 bflags, MonoBoolean ignore_case, struct MonoReflectionType * reftype)
{
  void * D.30342;
  struct MonoClass * System_Reflection_PropertyInfo.139;
  struct MonoImage * D.30346;
  struct MonoClass * System_Reflection_PropertyInfo.140;
  struct MonoVTable * D.30348;
  struct MonoType * D.30349;
  long unsigned int D.30350;
  long unsigned int D.30351;
  struct MonoArray * D.30354;
  struct MonoClass * D.22895;
  struct MonoClass * tmp_klass.141;
  struct MonoClass * tmp_klass.142;
  _Bool D.30359;
  long int D.30360;
  long int D.30361;
  struct MonoVTable * D.30364;
  int (*<T3a56>) (const char *, const char *) iftmp.143;
  unsigned char D.30371;
  struct MonoLoaderError * D.30373;
  short unsigned int D.30379;
  struct MonoMethod * D.30385;
  short unsigned int D.30387;
  int D.30388;
  int D.30389;
  struct MonoMethod * D.30390;
  short unsigned int D.30392;
  int D.30393;
  int D.30394;
  unsigned int D.30395;
  unsigned int D.30398;
  _Bool D.30403;
  int D.30404;
  int D.30405;
  int D.30407;
  unsigned int D.30410;
  unsigned int D.30413;
  unsigned int D.30418;
  unsigned int D.30421;
  const char * D.30428;
  int D.30429;
  void * D.30432;
  int D.30435;
  int D.30436;
  long unsigned int D.30439;
  long unsigned int D.30440;
  int D.30441;
  void * D.30442;
  void * * D.30443;
  long unsigned int D.30444;
  int D.30447;
  int D.30448;
  long unsigned int D.30449;
  long unsigned int D.30450;
  void * * D.30451;
  struct MonoReflectionProperty * D.30452;
  unsigned int D.30453;
  struct MonoClass * D.22903;
  struct MonoClass * tmp_klass.144;
  struct MonoClass * tmp_klass.145;
  _Bool D.30461;
  long int D.30462;
  long int D.30463;
  struct MonoVTable * D.30466;
  long unsigned int D.30467;
  long unsigned int D.30468;
  long unsigned int D.30469;
  long unsigned int D.30470;
  void * * D.30471;
  void * D.30472;
  struct MonoLoaderError * D.30484;
  struct MonoException * ex;
  struct MonoDomain * domain;
  static struct MonoClass * System_Reflection_PropertyInfo;
  struct MonoClass * startklass;
  struct MonoClass * klass;
  struct MonoArray * res;
  struct MonoMethod * method;
  struct MonoProperty * prop;
  int i;
  int match;
  guint32 flags;
  gchar * propname;
  int (*<T3a56>) (const char *, const char *) compare_func;
  void * iter;
  struct GHashTable * properties;
  struct MonoPtrArray tmp_array;
  void handle_parent = <<< error >>>;
  void loader_error = <<< error >>>;

  try
    {
      propname = 0B;
      compare_func = 0B;
      properties = 0B;
      tmp_array.size = 0;
      tmp_array.capacity = 16;
      D.30342 = __builtin_alloca (128);
      tmp_array.data = D.30342;
      System_Reflection_PropertyInfo.139 = System_Reflection_PropertyInfo;
      if (System_Reflection_PropertyInfo.139 == 0B) goto <D.30344>; else goto <D.30345>;
      <D.30344>:
      D.30346 = mono_defaults.corlib;
      System_Reflection_PropertyInfo.140 = mono_class_from_name (D.30346, "System.Reflection", "PropertyInfo");
      System_Reflection_PropertyInfo = System_Reflection_PropertyInfo.140;
      <D.30345>:
      D.30348 = MEM[(struct MonoObject *)type].vtable;
      domain = D.30348->domain;
      D.30349 = type->type;
      D.30350 = BIT_FIELD_REF <*D.30349, 64, 64>;
      D.30351 = D.30350 & 1073741824;
      if (D.30351 != 0) goto <D.30352>; else goto <D.30353>;
      <D.30352>:
      {
        static struct MonoClass * tmp_klass;

        {
          tmp_klass.141 = tmp_klass;
          if (tmp_klass.141 == 0B) goto <D.30356>; else goto <D.30357>;
          <D.30356>:
          System_Reflection_PropertyInfo.139 = System_Reflection_PropertyInfo;
          tmp_klass.142 = mono_array_class_get (System_Reflection_PropertyInfo.139, 1);
          tmp_klass = tmp_klass.142;
          tmp_klass.141 = tmp_klass;
          D.30359 = tmp_klass.141 == 0B;
          D.30360 = (long int) D.30359;
          D.30361 = __builtin_expect (D.30360, 0);
          if (D.30361 != 0) goto <D.30362>; else goto <D.30363>;
          <D.30362>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "icall.c", 3725, "tmp_klass");
          <D.30363>:
          <D.30357>:
        }
        D.22895 = tmp_klass;
      }
      D.30364 = mono_class_vtable (domain, D.22895);
      D.30354 = mono_array_new_specific (D.30364, 0);
      return D.30354;
      <D.30353>:
      D.30349 = type->type;
      startklass = mono_class_from_mono_type (D.30349);
      klass = startklass;
      if (name != 0B) goto <D.30365>; else goto <D.30366>;
      <D.30365>:
      propname = mono_string_to_utf8 (name);
      if (ignore_case != 0) goto <D.30368>; else goto <D.30369>;
      <D.30368>:
      iftmp.143 = monoeg_ascii_strcasecmp;
      goto <D.30370>;
      <D.30369>:
      iftmp.143 = strcmp;
      <D.30370>:
      compare_func = iftmp.143;
      <D.30366>:
      properties = monoeg_g_hash_table_new (property_hash, property_equal);
      handle_parent:
      mono_class_setup_vtable (klass);
      D.30371 = klass->exception_type;
      if (D.30371 != 0) goto loader_error; else goto <D.30372>;
      <D.30372>:
      D.30373 = mono_loader_get_last_error ();
      if (D.30373 != 0B) goto loader_error; else goto <D.30374>;
      <D.30374>:
      iter = 0B;
      goto <D.22898>;
      <D.22900>:
      match = 0;
      method = prop->get;
      if (method == 0B) goto <D.30375>; else goto <D.30376>;
      <D.30375>:
      method = prop->set;
      <D.30376>:
      if (method != 0B) goto <D.30377>; else goto <D.30378>;
      <D.30377>:
      D.30379 = method->flags;
      flags = (guint32) D.30379;
      goto <D.30380>;
      <D.30378>:
      flags = 0;
      <D.30380>:
      D.30385 = prop->get;
      if (D.30385 != 0B) goto <D.30386>; else goto <D.30381>;
      <D.30386>:
      D.30385 = prop->get;
      D.30387 = D.30385->flags;
      D.30388 = (int) D.30387;
      D.30389 = D.30388 & 7;
      if (D.30389 == 6) goto <D.30382>; else goto <D.30381>;
      <D.30381>:
      D.30390 = prop->set;
      if (D.30390 != 0B) goto <D.30391>; else goto <D.30383>;
      <D.30391>:
      D.30390 = prop->set;
      D.30392 = D.30390->flags;
      D.30393 = (int) D.30392;
      D.30394 = D.30393 & 7;
      if (D.30394 == 6) goto <D.30382>; else goto <D.30383>;
      <D.30382>:
      D.30395 = bflags & 16;
      if (D.30395 != 0) goto <D.30396>; else goto <D.30397>;
      <D.30396>:
      match = match + 1;
      <D.30397>:
      goto <D.30384>;
      <D.30383>:
      D.30398 = bflags & 32;
      if (D.30398 != 0) goto <D.30399>; else goto <D.30400>;
      <D.30399>:
      D.30385 = prop->get;
      D.30403 = startklass == klass;
      D.30404 = (int) D.30403;
      D.30405 = property_accessor_nonpublic (D.30385, D.30404);
      if (D.30405 != 0) goto <D.30401>; else goto <D.30406>;
      <D.30406>:
      D.30390 = prop->set;
      D.30403 = startklass == klass;
      D.30404 = (int) D.30403;
      D.30407 = property_accessor_nonpublic (D.30390, D.30404);
      if (D.30407 != 0) goto <D.30401>; else goto <D.30402>;
      <D.30401>:
      match = match + 1;
      <D.30402>:
      <D.30400>:
      <D.30384>:
      if (match == 0) goto <D.30408>; else goto <D.30409>;
      <D.30408>:
      // predicted unlikely by continue predictor.
      goto <D.22898>;
      <D.30409>:
      match = 0;
      D.30410 = flags & 16;
      if (D.30410 != 0) goto <D.30411>; else goto <D.30412>;
      <D.30411>:
      D.30413 = bflags & 8;
      if (D.30413 != 0) goto <D.30414>; else goto <D.30415>;
      <D.30414>:
      D.30418 = bflags & 64;
      if (D.30418 != 0) goto <D.30416>; else goto <D.30419>;
      <D.30419>:
      if (klass == startklass) goto <D.30416>; else goto <D.30417>;
      <D.30416>:
      match = match + 1;
      <D.30417>:
      <D.30415>:
      goto <D.30420>;
      <D.30412>:
      D.30421 = bflags & 4;
      if (D.30421 != 0) goto <D.30422>; else goto <D.30423>;
      <D.30422>:
      match = match + 1;
      <D.30423>:
      <D.30420>:
      if (match == 0) goto <D.30424>; else goto <D.30425>;
      <D.30424>:
      // predicted unlikely by continue predictor.
      goto <D.22898>;
      <D.30425>:
      match = 0;
      if (name != 0B) goto <D.30426>; else goto <D.30427>;
      <D.30426>:
      D.30428 = prop->name;
      D.30429 = compare_func (propname, D.30428);
      if (D.30429 != 0) goto <D.30430>; else goto <D.30431>;
      <D.30430>:
      // predicted unlikely by continue predictor.
      goto <D.22898>;
      <D.30431>:
      <D.30427>:
      D.30432 = monoeg_g_hash_table_lookup (properties, prop);
      if (D.30432 != 0B) goto <D.30433>; else goto <D.30434>;
      <D.30433>:
      // predicted unlikely by continue predictor.
      goto <D.22898>;
      <D.30434>:
      D.30435 = tmp_array.size;
      D.30436 = tmp_array.capacity;
      if (D.30435 >= D.30436) goto <D.30437>; else goto <D.30438>;
      <D.30437>:
      {
        void * __tmp;

        D.30436 = tmp_array.capacity;
        D.30439 = (long unsigned int) D.30436;
        D.30440 = D.30439 * 16;
        D.30436 = tmp_array.capacity;
        D.30441 = D.30436 * 2;
        D.30442 = mono_gc_make_root_descr_all_refs (D.30441);
        __tmp = mono_gc_alloc_fixed (D.30440, D.30442);
        D.30443 = tmp_array.data;
        D.30436 = tmp_array.capacity;
        D.30439 = (long unsigned int) D.30436;
        D.30444 = D.30439 * 8;
        mono_gc_memmove_aligned (__tmp, D.30443, D.30444);
        D.30436 = tmp_array.capacity;
        if (D.30436 > 16) goto <D.30445>; else goto <D.30446>;
        <D.30445>:
        D.30443 = tmp_array.data;
        mono_gc_free_fixed (D.30443);
        <D.30446>:
        tmp_array.data = __tmp;
        D.30436 = tmp_array.capacity;
        D.30441 = D.30436 * 2;
        tmp_array.capacity = D.30441;
      }
      <D.30438>:
      D.30443 = tmp_array.data;
      D.30435 = tmp_array.size;
      D.30447 = D.30435;
      D.30448 = D.30447 + 1;
      tmp_array.size = D.30448;
      D.30449 = (long unsigned int) D.30447;
      D.30450 = D.30449 * 8;
      D.30451 = D.30443 + D.30450;
      D.30452 = mono_property_get_object (domain, startklass, prop);
      *D.30451 = D.30452;
      monoeg_g_hash_table_insert_replace (properties, prop, prop, 0);
      <D.22898>:
      prop = mono_class_get_properties (klass, &iter);
      if (prop != 0B) goto <D.22900>; else goto <D.22901>;
      <D.22901>:
      D.30453 = bflags & 2;
      if (D.30453 == 0) goto <D.30454>; else goto <D.30455>;
      <D.30454>:
      klass = klass->parent;
      if (klass != 0B) goto handle_parent; else goto <D.30456>;
      <D.30456>:
      <D.30455>:
      monoeg_g_hash_table_destroy (properties);
      monoeg_g_free (propname);
      {
        static struct MonoClass * tmp_klass;

        {
          tmp_klass.144 = tmp_klass;
          if (tmp_klass.144 == 0B) goto <D.30458>; else goto <D.30459>;
          <D.30458>:
          System_Reflection_PropertyInfo.139 = System_Reflection_PropertyInfo;
          tmp_klass.145 = mono_array_class_get (System_Reflection_PropertyInfo.139, 1);
          tmp_klass = tmp_klass.145;
          tmp_klass.144 = tmp_klass;
          D.30461 = tmp_klass.144 == 0B;
          D.30462 = (long int) D.30461;
          D.30463 = __builtin_expect (D.30462, 0);
          if (D.30463 != 0) goto <D.30464>; else goto <D.30465>;
          <D.30464>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "icall.c", 3793, "tmp_klass");
          <D.30465>:
          <D.30459>:
        }
        D.22903 = tmp_klass;
      }
      D.30466 = mono_class_vtable (domain, D.22903);
      D.30435 = tmp_array.size;
      D.30467 = (long unsigned int) D.30435;
      res = mono_array_new_specific (D.30466, D.30467);
      i = 0;
      goto <D.22906>;
      <D.22905>:
      {
        void * * __p;

        D.30468 = (long unsigned int) i;
        __p = mono_array_addr_with_size (res, 8, D.30468);
        D.30443 = tmp_array.data;
        D.30469 = (long unsigned int) i;
        D.30470 = D.30469 * 8;
        D.30471 = D.30443 + D.30470;
        D.30472 = *D.30471;
        mono_gc_wbarrier_set_arrayref (res, __p, D.30472);
      }
      i = i + 1;
      <D.22906>:
      D.30435 = tmp_array.size;
      if (D.30435 > i) goto <D.22905>; else goto <D.22907>;
      <D.22907>:
      D.30436 = tmp_array.capacity;
      if (D.30436 > 16) goto <D.30473>; else goto <D.30474>;
      <D.30473>:
      D.30443 = tmp_array.data;
      mono_gc_free_fixed (D.30443);
      <D.30474>:
      D.30354 = res;
      return D.30354;
      loader_error:
      if (properties != 0B) goto <D.30475>; else goto <D.30476>;
      <D.30475>:
      monoeg_g_hash_table_destroy (properties);
      <D.30476>:
      if (name != 0B) goto <D.30477>; else goto <D.30478>;
      <D.30477>:
      monoeg_g_free (propname);
      <D.30478>:
      D.30436 = tmp_array.capacity;
      if (D.30436 > 16) goto <D.30479>; else goto <D.30480>;
      <D.30479>:
      D.30443 = tmp_array.data;
      mono_gc_free_fixed (D.30443);
      <D.30480>:
      D.30371 = klass->exception_type;
      if (D.30371 != 0) goto <D.30481>; else goto <D.30482>;
      <D.30481>:
      ex = mono_class_get_exception_for_failure (klass);
      goto <D.30483>;
      <D.30482>:
      D.30484 = mono_loader_get_last_error ();
      ex = mono_loader_error_prepare_exception (D.30484);
      mono_loader_clear_error ();
      <D.30483>:
      mono_raise_exception (ex);
      D.30354 = 0B;
      return D.30354;
    }
  finally
    {
      iter = {CLOBBER};
      tmp_array = {CLOBBER};
    }
}


property_equal (struct MonoProperty * prop1, struct MonoProperty * prop2)
{
  const char * D.30487;
  const char * D.30488;
  int D.30489;
  gboolean D.30492;
  struct MonoMethod * D.30493;
  struct MonoMethod * D.30496;
  struct MonoMethodSignature * D.30499;
  struct MonoMethodSignature * D.30500;
  int D.30501;
  struct MonoMethod * D.30504;
  struct MonoMethod * D.30507;
  struct MonoMethodSignature * D.30510;
  struct MonoMethodSignature * D.30511;
  int D.30512;

  D.30487 = prop1->name;
  D.30488 = prop2->name;
  D.30489 = monoeg_g_str_equal (D.30487, D.30488);
  if (D.30489 == 0) goto <D.30490>; else goto <D.30491>;
  <D.30490>:
  D.30492 = 0;
  return D.30492;
  <D.30491>:
  D.30493 = prop1->get;
  if (D.30493 != 0B) goto <D.30494>; else goto <D.30495>;
  <D.30494>:
  D.30496 = prop2->get;
  if (D.30496 != 0B) goto <D.30497>; else goto <D.30498>;
  <D.30497>:
  D.30493 = prop1->get;
  D.30499 = mono_method_signature (D.30493);
  D.30496 = prop2->get;
  D.30500 = mono_method_signature (D.30496);
  D.30501 = mono_metadata_signature_equal (D.30499, D.30500);
  if (D.30501 == 0) goto <D.30502>; else goto <D.30503>;
  <D.30502>:
  D.30492 = 0;
  return D.30492;
  <D.30503>:
  <D.30498>:
  <D.30495>:
  D.30504 = prop1->set;
  if (D.30504 != 0B) goto <D.30505>; else goto <D.30506>;
  <D.30505>:
  D.30507 = prop2->set;
  if (D.30507 != 0B) goto <D.30508>; else goto <D.30509>;
  <D.30508>:
  D.30504 = prop1->set;
  D.30510 = mono_method_signature (D.30504);
  D.30507 = prop2->set;
  D.30511 = mono_method_signature (D.30507);
  D.30512 = mono_metadata_signature_equal (D.30510, D.30511);
  if (D.30512 == 0) goto <D.30513>; else goto <D.30514>;
  <D.30513>:
  D.30492 = 0;
  return D.30492;
  <D.30514>:
  <D.30509>:
  <D.30506>:
  D.30492 = 1;
  return D.30492;
}


property_hash (const void * data)
{
  guint D.30516;
  const char * D.30517;
  struct MonoProperty * prop;

  prop = data;
  D.30517 = prop->name;
  D.30516 = monoeg_g_str_hash (D.30517);
  return D.30516;
}


property_accessor_nonpublic (struct MonoMethod * accessor, gboolean start_klass)
{
  gboolean D.30521;

  if (accessor == 0B) goto <D.30519>; else goto <D.30520>;
  <D.30519>:
  D.30521 = 0;
  return D.30521;
  <D.30520>:
  D.30521 = method_nonpublic (accessor, start_klass);
  return D.30521;
}


ves_icall_Type_GetNestedTypes (struct MonoReflectionType * type, guint32 bflags)
{
  struct MonoVTable * D.30523;
  struct MonoType * D.30524;
  long unsigned int D.30525;
  long unsigned int D.30526;
  struct MonoArray * D.30529;
  struct MonoClass * D.30530;
  struct MonoGenericClass * D.30531;
  void * D.30534;
  unsigned int D.30535;
  unsigned int D.30536;
  unsigned int D.30539;
  unsigned int D.30543;
  struct MonoType * D.30548;
  int D.30549;
  int D.30550;
  long unsigned int D.30553;
  long unsigned int D.30554;
  int D.30555;
  void * D.30556;
  void * * D.30557;
  long unsigned int D.30558;
  int D.30561;
  int D.30562;
  long unsigned int D.30563;
  long unsigned int D.30564;
  void * * D.30565;
  struct MonoClass * D.23000;
  struct MonoClass * tmp_klass.146;
  struct MonoClass * tmp_klass.147;
  _Bool D.30570;
  long int D.30571;
  long int D.30572;
  struct MonoVTable * D.30575;
  long unsigned int D.30576;
  long unsigned int D.30577;
  long unsigned int D.30578;
  long unsigned int D.30579;
  void * * D.30580;
  void * D.30581;
  struct MonoDomain * domain;
  struct MonoClass * klass;
  struct MonoArray * res;
  struct MonoObject * member;
  int i;
  int match;
  struct MonoClass * nested;
  void * iter;
  struct MonoPtrArray tmp_array;

  try
    {
      D.30523 = MEM[(struct MonoObject *)type].vtable;
      domain = D.30523->domain;
      D.30524 = type->type;
      D.30525 = BIT_FIELD_REF <*D.30524, 64, 64>;
      D.30526 = D.30525 & 1073741824;
      if (D.30526 != 0) goto <D.30527>; else goto <D.30528>;
      <D.30527>:
      D.30530 = mono_defaults.monotype_class;
      D.30529 = mono_array_new (domain, D.30530, 0);
      return D.30529;
      <D.30528>:
      D.30524 = type->type;
      klass = mono_class_from_mono_type (D.30524);
      D.30531 = klass->generic_class;
      if (D.30531 != 0B) goto <D.30532>; else goto <D.30533>;
      <D.30532>:
      D.30531 = klass->generic_class;
      klass = D.30531->container_class;
      <D.30533>:
      tmp_array.size = 0;
      tmp_array.capacity = 16;
      D.30534 = __builtin_alloca (128);
      tmp_array.data = D.30534;
      iter = 0B;
      goto <D.22995>;
      <D.22997>:
      match = 0;
      D.30535 = nested->flags;
      D.30536 = D.30535 & 7;
      if (D.30536 == 2) goto <D.30537>; else goto <D.30538>;
      <D.30537>:
      D.30539 = bflags & 16;
      if (D.30539 != 0) goto <D.30540>; else goto <D.30541>;
      <D.30540>:
      match = match + 1;
      <D.30541>:
      goto <D.30542>;
      <D.30538>:
      D.30543 = bflags & 32;
      if (D.30543 != 0) goto <D.30544>; else goto <D.30545>;
      <D.30544>:
      match = match + 1;
      <D.30545>:
      <D.30542>:
      if (match == 0) goto <D.30546>; else goto <D.30547>;
      <D.30546>:
      // predicted unlikely by continue predictor.
      goto <D.22995>;
      <D.30547>:
      D.30548 = &nested->byval_arg;
      member = mono_type_get_object (domain, D.30548);
      D.30549 = tmp_array.size;
      D.30550 = tmp_array.capacity;
      if (D.30549 >= D.30550) goto <D.30551>; else goto <D.30552>;
      <D.30551>:
      {
        void * __tmp;

        D.30550 = tmp_array.capacity;
        D.30553 = (long unsigned int) D.30550;
        D.30554 = D.30553 * 16;
        D.30550 = tmp_array.capacity;
        D.30555 = D.30550 * 2;
        D.30556 = mono_gc_make_root_descr_all_refs (D.30555);
        __tmp = mono_gc_alloc_fixed (D.30554, D.30556);
        D.30557 = tmp_array.data;
        D.30550 = tmp_array.capacity;
        D.30553 = (long unsigned int) D.30550;
        D.30558 = D.30553 * 8;
        mono_gc_memmove_aligned (__tmp, D.30557, D.30558);
        D.30550 = tmp_array.capacity;
        if (D.30550 > 16) goto <D.30559>; else goto <D.30560>;
        <D.30559>:
        D.30557 = tmp_array.data;
        mono_gc_free_fixed (D.30557);
        <D.30560>:
        tmp_array.data = __tmp;
        D.30550 = tmp_array.capacity;
        D.30555 = D.30550 * 2;
        tmp_array.capacity = D.30555;
      }
      <D.30552>:
      D.30557 = tmp_array.data;
      D.30549 = tmp_array.size;
      D.30561 = D.30549;
      D.30562 = D.30561 + 1;
      tmp_array.size = D.30562;
      D.30563 = (long unsigned int) D.30561;
      D.30564 = D.30563 * 8;
      D.30565 = D.30557 + D.30564;
      *D.30565 = member;
      <D.22995>:
      nested = mono_class_get_nested_types (klass, &iter);
      if (nested != 0B) goto <D.22997>; else goto <D.22998>;
      <D.22998>:
      {
        static struct MonoClass * tmp_klass;

        {
          tmp_klass.146 = tmp_klass;
          if (tmp_klass.146 == 0B) goto <D.30567>; else goto <D.30568>;
          <D.30567>:
          D.30530 = mono_defaults.monotype_class;
          tmp_klass.147 = mono_array_class_get (D.30530, 1);
          tmp_klass = tmp_klass.147;
          tmp_klass.146 = tmp_klass;
          D.30570 = tmp_klass.146 == 0B;
          D.30571 = (long int) D.30570;
          D.30572 = __builtin_expect (D.30571, 0);
          if (D.30572 != 0) goto <D.30573>; else goto <D.30574>;
          <D.30573>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "icall.c", 4094, "tmp_klass");
          <D.30574>:
          <D.30568>:
        }
        D.23000 = tmp_klass;
      }
      D.30575 = mono_class_vtable (domain, D.23000);
      D.30549 = tmp_array.size;
      D.30576 = (long unsigned int) D.30549;
      res = mono_array_new_specific (D.30575, D.30576);
      i = 0;
      goto <D.23003>;
      <D.23002>:
      {
        void * * __p;

        D.30577 = (long unsigned int) i;
        __p = mono_array_addr_with_size (res, 8, D.30577);
        D.30557 = tmp_array.data;
        D.30578 = (long unsigned int) i;
        D.30579 = D.30578 * 8;
        D.30580 = D.30557 + D.30579;
        D.30581 = *D.30580;
        mono_gc_wbarrier_set_arrayref (res, __p, D.30581);
      }
      i = i + 1;
      <D.23003>:
      D.30549 = tmp_array.size;
      if (D.30549 > i) goto <D.23002>; else goto <D.23004>;
      <D.23004>:
      D.30550 = tmp_array.capacity;
      if (D.30550 > 16) goto <D.30582>; else goto <D.30583>;
      <D.30582>:
      D.30557 = tmp_array.data;
      mono_gc_free_fixed (D.30557);
      <D.30583>:
      D.30529 = res;
      return D.30529;
    }
  finally
    {
      iter = {CLOBBER};
      tmp_array = {CLOBBER};
    }
}


ves_icall_Type_GetNestedType (struct MonoReflectionType * type, struct MonoString * name, guint32 bflags)
{
  struct MonoException * D.30588;
  struct MonoVTable * D.30589;
  struct MonoType * D.30590;
  long unsigned int D.30591;
  long unsigned int D.30592;
  struct MonoReflectionType * D.30595;
  unsigned char D.30596;
  struct MonoException * D.30599;
  struct MonoGenericClass * D.30600;
  unsigned int D.30603;
  unsigned int D.30604;
  unsigned int D.30607;
  unsigned int D.30611;
  int D.22979;
  const char * D.30616;
  struct MonoType * D.30619;
  unsigned int D.30620;
  struct MonoDomain * domain;
  struct MonoClass * klass;
  struct MonoClass * nested;
  char * str;
  void * iter;
  void handle_parent = <<< error >>>;

  try
    {
      if (name == 0B) goto <D.30586>; else goto <D.30587>;
      <D.30586>:
      D.30588 = mono_get_exception_argument_null ("name");
      mono_raise_exception (D.30588);
      <D.30587>:
      D.30589 = MEM[(struct MonoObject *)type].vtable;
      domain = D.30589->domain;
      D.30590 = type->type;
      D.30591 = BIT_FIELD_REF <*D.30590, 64, 64>;
      D.30592 = D.30591 & 1073741824;
      if (D.30592 != 0) goto <D.30593>; else goto <D.30594>;
      <D.30593>:
      D.30595 = 0B;
      return D.30595;
      <D.30594>:
      D.30590 = type->type;
      klass = mono_class_from_mono_type (D.30590);
      str = mono_string_to_utf8 (name);
      handle_parent:
      D.30596 = klass->exception_type;
      if (D.30596 != 0) goto <D.30597>; else goto <D.30598>;
      <D.30597>:
      D.30599 = mono_class_get_exception_for_failure (klass);
      mono_raise_exception (D.30599);
      <D.30598>:
      D.30600 = klass->generic_class;
      if (D.30600 != 0B) goto <D.30601>; else goto <D.30602>;
      <D.30601>:
      D.30600 = klass->generic_class;
      klass = D.30600->container_class;
      <D.30602>:
      iter = 0B;
      goto <D.22970>;
      <D.22980>:
      {
        int match;

        match = 0;
        D.30603 = nested->flags;
        D.30604 = D.30603 & 7;
        if (D.30604 == 2) goto <D.30605>; else goto <D.30606>;
        <D.30605>:
        D.30607 = bflags & 16;
        if (D.30607 != 0) goto <D.30608>; else goto <D.30609>;
        <D.30608>:
        match = match + 1;
        <D.30609>:
        goto <D.30610>;
        <D.30606>:
        D.30611 = bflags & 32;
        if (D.30611 != 0) goto <D.30612>; else goto <D.30613>;
        <D.30612>:
        match = match + 1;
        <D.30613>:
        <D.30610>:
        if (match == 0) goto <D.30614>; else goto <D.30615>;
        <D.30614>:
        // predicted unlikely by continue predictor.
        goto <D.22970>;
        <D.30615>:
        {
          size_t __s1_len;
          size_t __s2_len;

          D.30616 = nested->name;
          D.22979 = __builtin_strcmp (D.30616, str);
        }
        if (D.22979 == 0) goto <D.30617>; else goto <D.30618>;
        <D.30617>:
        monoeg_g_free (str);
        D.30619 = &nested->byval_arg;
        D.30595 = mono_type_get_object (domain, D.30619);
        return D.30595;
        <D.30618>:
      }
      <D.22970>:
      nested = mono_class_get_nested_types (klass, &iter);
      if (nested != 0B) goto <D.22980>; else goto <D.22981>;
      <D.22981>:
      D.30620 = bflags & 2;
      if (D.30620 == 0) goto <D.30621>; else goto <D.30622>;
      <D.30621>:
      klass = klass->parent;
      if (klass != 0B) goto handle_parent; else goto <D.30623>;
      <D.30623>:
      <D.30622>:
      monoeg_g_free (str);
      D.30595 = 0B;
      return D.30595;
    }
  finally
    {
      iter = {CLOBBER};
    }
}


ves_icall_Type_GetMethodsByName (struct MonoReflectionType * type, struct MonoString * name, guint32 bflags, MonoBoolean ignore_case, struct MonoReflectionType * reftype)
{
  struct MonoClass * MethodInfo_array.148;
  struct MonoClass * D.30629;
  struct MonoType * D.30630;
  struct MonoType * D.30631;
  struct MonoVTable * D.30632;
  long unsigned int D.30633;
  long unsigned int D.30634;
  struct MonoArray * D.30637;
  int D.30640;
  struct MonoException * ex.149;
  unsigned int D.30644;
  long unsigned int D.30645;
  void * * D.30646;
  long unsigned int D.30647;
  long unsigned int D.30648;
  void * * D.30649;
  long unsigned int D.30650;
  struct MonoReflectionMethod * D.30651;
  unsigned int i.150;
  static struct MonoClass * MethodInfo_array;
  struct MonoDomain * domain;
  struct MonoArray * res;
  struct MonoVTable * array_vtable;
  struct MonoException * ex;
  const char * mname;
  struct GPtrArray * method_array;
  struct MonoClass * klass;
  struct MonoClass * refklass;
  int i;

  try
    {
      ex = 0B;
      mname = 0B;
      MethodInfo_array.148 = MethodInfo_array;
      if (MethodInfo_array.148 == 0B) goto <D.30627>; else goto <D.30628>;
      <D.30627>:
      {
        struct MonoClass * klass;

        D.30629 = mono_defaults.method_info_class;
        klass = mono_array_class_get (D.30629, 1);
        mono_memory_barrier ();
        MethodInfo_array = klass;
      }
      <D.30628>:
      D.30630 = type->type;
      klass = mono_class_from_mono_type (D.30630);
      D.30631 = reftype->type;
      refklass = mono_class_from_mono_type (D.30631);
      D.30632 = MEM[(struct MonoObject *)type].vtable;
      domain = D.30632->domain;
      MethodInfo_array.148 = MethodInfo_array;
      array_vtable = mono_class_vtable_full (domain, MethodInfo_array.148, 1);
      D.30630 = type->type;
      D.30633 = BIT_FIELD_REF <*D.30630, 64, 64>;
      D.30634 = D.30633 & 1073741824;
      if (D.30634 != 0) goto <D.30635>; else goto <D.30636>;
      <D.30635>:
      D.30637 = mono_array_new_specific (array_vtable, 0);
      return D.30637;
      <D.30636>:
      if (name != 0B) goto <D.30638>; else goto <D.30639>;
      <D.30638>:
      mname = mono_string_to_utf8 (name);
      <D.30639>:
      D.30640 = (int) ignore_case;
      method_array = mono_class_get_methods_by_name (klass, mname, bflags, D.30640, 0, &ex);
      monoeg_g_free (mname);
      ex.149 = ex;
      if (ex.149 != 0B) goto <D.30642>; else goto <D.30643>;
      <D.30642>:
      ex.149 = ex;
      mono_raise_exception (ex.149);
      <D.30643>:
      D.30644 = method_array->len;
      D.30645 = (long unsigned int) D.30644;
      res = mono_array_new_specific (array_vtable, D.30645);
      i = 0;
      goto <D.22808>;
      <D.22807>:
      {
        struct MonoMethod * method;

        D.30646 = method_array->pdata;
        D.30647 = (long unsigned int) i;
        D.30648 = D.30647 * 8;
        D.30649 = D.30646 + D.30648;
        method = *D.30649;
        {
          void * * __p;

          D.30650 = (long unsigned int) i;
          __p = mono_array_addr_with_size (res, 8, D.30650);
          D.30651 = mono_method_get_object (domain, method, refklass);
          mono_gc_wbarrier_set_arrayref (res, __p, D.30651);
        }
      }
      i = i + 1;
      <D.22808>:
      i.150 = (unsigned int) i;
      D.30644 = method_array->len;
      if (i.150 < D.30644) goto <D.22807>; else goto <D.22809>;
      <D.22809>:
      monoeg_g_ptr_array_free (method_array, 1);
      D.30637 = res;
      return D.30637;
    }
  finally
    {
      ex = {CLOBBER};
    }
}


mono_memory_barrier ()
{
  __sync_synchronize ();
}


ves_icall_Type_GetInterfaces (struct MonoReflectionType * type)
{
  struct MonoType * D.30655;
  struct MonoGenericClass * D.30656;
  struct MonoGenericInst * D.30659;
  long unsigned int D.30660;
  long unsigned int D.30661;
  struct MonoGenericContext * D.30664;
  int D.30665;
  int D.30667;
  struct MonoVTable * D.30669;
  struct MonoDomain * D.30670;
  unsigned int D.30671;
  struct MonoDomain * D.30674;
  struct MonoArray * D.30675;
  struct MonoClass * D.22133;
  struct MonoClass * tmp_klass.151;
  struct MonoClass * D.30681;
  struct MonoClass * tmp_klass.152;
  _Bool D.30683;
  long int D.30684;
  long int D.30685;
  struct MonoVTable * D.30688;
  struct MonoArray * D.30689;
  struct MonoArray * D.30690;
  struct MonoClass * D.22135;
  struct MonoClass * tmp_klass.153;
  struct MonoClass * tmp_klass.154;
  _Bool D.30695;
  long int D.30696;
  long int D.30697;
  struct MonoVTable * D.30700;
  long unsigned int D.30701;
  struct MonoArray * D.30702;
  int D.30703;
  struct MonoError error;
  struct MonoClass * class;
  struct MonoClass * parent;
  struct FillIfaceArrayData data;
  int len;
  struct GHashTable * iface_hash;
  void fail = <<< error >>>;

  try
    {
      D.30655 = type->type;
      class = mono_class_from_mono_type (D.30655);
      data = {};
      iface_hash = monoeg_g_hash_table_new (0B, 0B);
      D.30656 = class->generic_class;
      if (D.30656 != 0B) goto <D.30657>; else goto <D.30658>;
      <D.30657>:
      D.30656 = class->generic_class;
      D.30659 = D.30656->context.class_inst;
      D.30660 = BIT_FIELD_REF <*D.30659, 64, 0>;
      D.30661 = D.30660 & 18014398509481984;
      if (D.30661 != 0) goto <D.30662>; else goto <D.30663>;
      <D.30662>:
      D.30664 = mono_class_get_context (class);
      data.context = D.30664;
      D.30656 = class->generic_class;
      class = D.30656->container_class;
      <D.30663>:
      <D.30658>:
      parent = class;
      goto <D.22130>;
      <D.22129>:
      mono_class_setup_interfaces (parent, &error);
      D.30665 = mono_error_ok (&error);
      if (D.30665 == 0) goto fail; else goto <D.30666>;
      <D.30666>:
      collect_interfaces (parent, iface_hash, &error);
      D.30667 = mono_error_ok (&error);
      if (D.30667 == 0) goto fail; else goto <D.30668>;
      <D.30668>:
      parent = parent->parent;
      <D.22130>:
      if (parent != 0B) goto <D.22129>; else goto <D.22131>;
      <D.22131>:
      data.error = &error;
      D.30669 = MEM[(struct MonoObject *)type].vtable;
      D.30670 = D.30669->domain;
      data.domain = D.30670;
      D.30671 = monoeg_g_hash_table_size (iface_hash);
      len = (int) D.30671;
      if (len == 0) goto <D.30672>; else goto <D.30673>;
      <D.30672>:
      monoeg_g_hash_table_destroy (iface_hash);
      D.30674 = data.domain;
      D.30675 = D.30674->empty_types;
      if (D.30675 == 0B) goto <D.30676>; else goto <D.30677>;
      <D.30676>:
      D.30674 = data.domain;
      D.30674 = data.domain;
      {
        static struct MonoClass * tmp_klass;

        {
          tmp_klass.151 = tmp_klass;
          if (tmp_klass.151 == 0B) goto <D.30679>; else goto <D.30680>;
          <D.30679>:
          D.30681 = mono_defaults.monotype_class;
          tmp_klass.152 = mono_array_class_get (D.30681, 1);
          tmp_klass = tmp_klass.152;
          tmp_klass.151 = tmp_klass;
          D.30683 = tmp_klass.151 == 0B;
          D.30684 = (long int) D.30683;
          D.30685 = __builtin_expect (D.30684, 0);
          if (D.30685 != 0) goto <D.30686>; else goto <D.30687>;
          <D.30686>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "icall.c", 2107, "tmp_klass");
          <D.30687>:
          <D.30680>:
        }
        D.22133 = tmp_klass;
      }
      D.30688 = mono_class_vtable (D.30674, D.22133);
      D.30689 = mono_array_new_specific (D.30688, 0);
      D.30674->empty_types = D.30689;
      <D.30677>:
      D.30674 = data.domain;
      D.30690 = D.30674->empty_types;
      return D.30690;
      <D.30673>:
      D.30674 = data.domain;
      {
        static struct MonoClass * tmp_klass;

        {
          tmp_klass.153 = tmp_klass;
          if (tmp_klass.153 == 0B) goto <D.30692>; else goto <D.30693>;
          <D.30692>:
          D.30681 = mono_defaults.monotype_class;
          tmp_klass.154 = mono_array_class_get (D.30681, 1);
          tmp_klass = tmp_klass.154;
          tmp_klass.153 = tmp_klass;
          D.30695 = tmp_klass.153 == 0B;
          D.30696 = (long int) D.30695;
          D.30697 = __builtin_expect (D.30696, 0);
          if (D.30697 != 0) goto <D.30698>; else goto <D.30699>;
          <D.30698>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "icall.c", 2111, "tmp_klass");
          <D.30699>:
          <D.30693>:
        }
        D.22135 = tmp_klass;
      }
      D.30700 = mono_class_vtable (D.30674, D.22135);
      D.30701 = (long unsigned int) len;
      D.30702 = mono_array_new_specific (D.30700, D.30701);
      data.iface_array = D.30702;
      monoeg_g_hash_table_foreach (iface_hash, fill_iface_array, &data);
      D.30703 = mono_error_ok (&error);
      if (D.30703 == 0) goto fail; else goto <D.30704>;
      <D.30704>:
      monoeg_g_hash_table_destroy (iface_hash);
      D.30690 = data.iface_array;
      return D.30690;
      fail:
      monoeg_g_hash_table_destroy (iface_hash);
      mono_error_raise_exception (&error);
      D.30690 = 0B;
      return D.30690;
    }
  finally
    {
      error = {CLOBBER};
      data = {CLOBBER};
    }
}


fill_iface_array (void * key, void * value, void * user_data)
{
  struct MonoError * D.30707;
  int D.30708;
  struct MonoGenericContext * D.30711;
  struct MonoGenericClass * D.30714;
  struct MonoGenericInst * D.30717;
  long unsigned int D.30718;
  long unsigned int D.30719;
  int D.30722;
  struct MonoArray * D.30725;
  int D.30726;
  int D.30727;
  int D.30728;
  long unsigned int D.30729;
  struct MonoDomain * D.30730;
  struct MonoReflectionType * D.30731;
  struct FillIfaceArrayData * data;
  struct MonoClass * ic;
  struct MonoType * ret;
  struct MonoType * inflated;

  data = user_data;
  ic = key;
  ret = &ic->byval_arg;
  inflated = 0B;
  D.30707 = data->error;
  D.30708 = mono_error_ok (D.30707);
  if (D.30708 == 0) goto <D.30709>; else goto <D.30710>;
  <D.30709>:
  return;
  <D.30710>:
  D.30711 = data->context;
  if (D.30711 != 0B) goto <D.30712>; else goto <D.30713>;
  <D.30712>:
  D.30714 = ic->generic_class;
  if (D.30714 != 0B) goto <D.30715>; else goto <D.30716>;
  <D.30715>:
  D.30714 = ic->generic_class;
  D.30717 = D.30714->context.class_inst;
  D.30718 = BIT_FIELD_REF <*D.30717, 64, 0>;
  D.30719 = D.30718 & 18014398509481984;
  if (D.30719 != 0) goto <D.30720>; else goto <D.30721>;
  <D.30720>:
  D.30711 = data->context;
  D.30707 = data->error;
  ret = mono_class_inflate_generic_type_checked (ret, D.30711, D.30707);
  inflated = ret;
  D.30707 = data->error;
  D.30722 = mono_error_ok (D.30707);
  if (D.30722 == 0) goto <D.30723>; else goto <D.30724>;
  <D.30723>:
  return;
  <D.30724>:
  <D.30721>:
  <D.30716>:
  <D.30713>:
  {
    void * * __p;

    D.30725 = data->iface_array;
    D.30726 = data->next_idx;
    D.30727 = D.30726;
    D.30728 = D.30727 + 1;
    data->next_idx = D.30728;
    D.30729 = (long unsigned int) D.30727;
    __p = mono_array_addr_with_size (D.30725, 8, D.30729);
    D.30725 = data->iface_array;
    D.30730 = data->domain;
    D.30731 = mono_type_get_object (D.30730, ret);
    mono_gc_wbarrier_set_arrayref (D.30725, __p, D.30731);
  }
  if (inflated != 0B) goto <D.30732>; else goto <D.30733>;
  <D.30732>:
  mono_metadata_free_type (inflated);
  <D.30733>:
}


collect_interfaces (struct MonoClass * klass, struct GHashTable * ifaces, struct MonoError * error)
{
  int D.30735;
  struct MonoClass * * D.30738;
  long unsigned int D.30739;
  long unsigned int D.30740;
  struct MonoClass * * D.30741;
  int D.30742;
  short unsigned int D.30745;
  int D.30746;
  int i;
  struct MonoClass * ic;

  mono_class_setup_interfaces (klass, error);
  D.30735 = mono_error_ok (error);
  if (D.30735 == 0) goto <D.30736>; else goto <D.30737>;
  <D.30736>:
  return;
  <D.30737>:
  i = 0;
  goto <D.22100>;
  <D.22099>:
  D.30738 = klass->interfaces;
  D.30739 = (long unsigned int) i;
  D.30740 = D.30739 * 8;
  D.30741 = D.30738 + D.30740;
  ic = *D.30741;
  monoeg_g_hash_table_insert_replace (ifaces, ic, ic, 0);
  collect_interfaces (ic, ifaces, error);
  D.30742 = mono_error_ok (error);
  if (D.30742 == 0) goto <D.30743>; else goto <D.30744>;
  <D.30743>:
  return;
  <D.30744>:
  i = i + 1;
  <D.22100>:
  D.30745 = klass->interface_count;
  D.30746 = (int) D.30745;
  if (D.30746 > i) goto <D.22099>; else goto <D.22101>;
  <D.22101>:
}


ves_icall_MonoType_GetGenericArguments (struct MonoReflectionType * type)
{
  struct MonoVTable * D.30748;
  struct MonoClass * D.22227;
  struct MonoClass * tmp_klass.155;
  struct MonoClass * D.30752;
  struct MonoClass * tmp_klass.156;
  _Bool D.30754;
  long int D.30755;
  long int D.30756;
  struct MonoType * D.30759;
  struct MonoGenericContainer * D.30760;
  <unnamed-signed:31> D.30763;
  long unsigned int D.30764;
  struct MonoGenericParamFull * D.30765;
  long unsigned int D.30766;
  long unsigned int D.30767;
  struct MonoGenericParam * D.30768;
  struct MonoImage * D.30769;
  long unsigned int D.30770;
  struct MonoType * D.30771;
  struct MonoReflectionType * D.30772;
  int D.30773;
  struct MonoGenericClass * D.30775;
  <unnamed-unsigned:22> D.30778;
  long unsigned int D.30779;
  struct MonoType * D.30780;
  struct MonoReflectionType * D.30781;
  int D.30782;
  struct MonoArray * D.30784;
  struct MonoArray * res;
  struct MonoClass * klass;
  struct MonoClass * pklass;
  struct MonoDomain * domain;
  struct MonoVTable * array_vtable;
  int i;

  D.30748 = MEM[(struct MonoObject *)type].vtable;
  domain = D.30748->domain;
  {
    static struct MonoClass * tmp_klass;

    {
      tmp_klass.155 = tmp_klass;
      if (tmp_klass.155 == 0B) goto <D.30750>; else goto <D.30751>;
      <D.30750>:
      D.30752 = mono_defaults.systemtype_class;
      tmp_klass.156 = mono_array_class_get (D.30752, 1);
      tmp_klass = tmp_klass.156;
      tmp_klass.155 = tmp_klass;
      D.30754 = tmp_klass.155 == 0B;
      D.30755 = (long int) D.30754;
      D.30756 = __builtin_expect (D.30755, 0);
      if (D.30756 != 0) goto <D.30757>; else goto <D.30758>;
      <D.30757>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "icall.c", 2329, "tmp_klass");
      <D.30758>:
      <D.30751>:
    }
    D.22227 = tmp_klass;
  }
  array_vtable = mono_class_vtable_full (domain, D.22227, 1);
  D.30759 = type->type;
  klass = mono_class_from_mono_type (D.30759);
  D.30760 = klass->generic_container;
  if (D.30760 != 0B) goto <D.30761>; else goto <D.30762>;
  <D.30761>:
  {
    struct MonoGenericContainer * container;

    container = klass->generic_container;
    D.30763 = container->type_argc;
    D.30764 = (long unsigned int) D.30763;
    res = mono_array_new_specific (array_vtable, D.30764);
    i = 0;
    goto <D.22232>;
    <D.22231>:
    D.30765 = container->type_params;
    D.30766 = (long unsigned int) i;
    D.30767 = D.30766 * 56;
    D.30768 = D.30765 + D.30767;
    D.30769 = klass->image;
    pklass = mono_class_from_generic_parameter (D.30768, D.30769, 0);
    {
      void * * __p;

      D.30770 = (long unsigned int) i;
      __p = mono_array_addr_with_size (res, 8, D.30770);
      D.30771 = &pklass->byval_arg;
      D.30772 = mono_type_get_object (domain, D.30771);
      mono_gc_wbarrier_set_arrayref (res, __p, D.30772);
    }
    i = i + 1;
    <D.22232>:
    D.30763 = container->type_argc;
    D.30773 = (int) D.30763;
    if (D.30773 > i) goto <D.22231>; else goto <D.22233>;
    <D.22233>:
  }
  goto <D.30774>;
  <D.30762>:
  D.30775 = klass->generic_class;
  if (D.30775 != 0B) goto <D.30776>; else goto <D.30777>;
  <D.30776>:
  {
    struct MonoGenericInst * inst;

    D.30775 = klass->generic_class;
    inst = D.30775->context.class_inst;
    D.30778 = inst->type_argc;
    D.30779 = (long unsigned int) D.30778;
    res = mono_array_new_specific (array_vtable, D.30779);
    i = 0;
    goto <D.22237>;
    <D.22236>:
    {
      void * * __p;

      D.30770 = (long unsigned int) i;
      __p = mono_array_addr_with_size (res, 8, D.30770);
      D.30780 = inst->type_argv[i];
      D.30781 = mono_type_get_object (domain, D.30780);
      mono_gc_wbarrier_set_arrayref (res, __p, D.30781);
    }
    i = i + 1;
    <D.22237>:
    D.30778 = inst->type_argc;
    D.30782 = (int) D.30778;
    if (D.30782 > i) goto <D.22236>; else goto <D.22238>;
    <D.22238>:
  }
  goto <D.30783>;
  <D.30777>:
  res = mono_array_new_specific (array_vtable, 0);
  <D.30783>:
  <D.30774>:
  D.30784 = res;
  return D.30784;
}


ves_icall_Type_GetFields_internal (struct MonoReflectionType * type, guint32 bflags, struct MonoReflectionType * reftype)
{
  struct MonoVTable * D.30786;
  struct MonoType * D.30787;
  long unsigned int D.30788;
  long unsigned int D.30789;
  struct MonoArray * D.30792;
  struct MonoClass * D.30793;
  struct MonoType * D.30794;
  void * D.30795;
  unsigned char D.30796;
  int D.30799;
  void * * D.30802;
  struct MonoException * D.30803;
  unsigned int D.30804;
  int D.22716;
  int iftmp.157;
  int D.22715;
  const char[9] * D.30810;
  unsigned char D.30811;
  int D.30812;
  unsigned char D.30813;
  int D.30814;
  const unsigned char * D.30819;
  unsigned char D.30820;
  int D.30821;
  const unsigned char * D.30822;
  unsigned char D.30823;
  int D.30824;
  const unsigned char * D.30829;
  unsigned char D.30830;
  int D.30831;
  const unsigned char * D.30832;
  unsigned char D.30833;
  int D.30834;
  const unsigned char * D.30839;
  unsigned char D.30840;
  int D.30841;
  const unsigned char * D.30842;
  unsigned char D.30843;
  int D.30844;
  const char * D.30846;
  unsigned int D.30849;
  unsigned int D.30852;
  unsigned int D.30859;
  unsigned int D.30864;
  unsigned int D.30867;
  unsigned int D.30872;
  unsigned int D.30875;
  int D.30880;
  long unsigned int D.30883;
  long unsigned int D.30884;
  int D.30885;
  void * D.30886;
  long unsigned int D.30887;
  int D.30890;
  int D.30891;
  long unsigned int D.30892;
  long unsigned int D.30893;
  void * * D.30894;
  unsigned int D.30895;
  struct MonoClass * D.22722;
  struct MonoClass * tmp_klass.158;
  struct MonoClass * tmp_klass.159;
  _Bool D.30903;
  long int D.30904;
  long int D.30905;
  struct MonoVTable * D.30908;
  long unsigned int D.30909;
  long unsigned int D.30910;
  long unsigned int D.30911;
  long unsigned int D.30912;
  void * * D.30913;
  void * D.30914;
  struct MonoDomain * domain;
  struct MonoClass * startklass;
  struct MonoClass * klass;
  struct MonoClass * refklass;
  struct MonoArray * res;
  struct MonoObject * member;
  int i;
  int match;
  void * iter;
  struct MonoClassField * field;
  struct MonoPtrArray tmp_array;
  void handle_parent = <<< error >>>;

  try
    {
      D.30786 = MEM[(struct MonoObject *)type].vtable;
      domain = D.30786->domain;
      D.30787 = type->type;
      D.30788 = BIT_FIELD_REF <*D.30787, 64, 64>;
      D.30789 = D.30788 & 1073741824;
      if (D.30789 != 0) goto <D.30790>; else goto <D.30791>;
      <D.30790>:
      D.30793 = mono_defaults.field_info_class;
      D.30792 = mono_array_new (domain, D.30793, 0);
      return D.30792;
      <D.30791>:
      D.30787 = type->type;
      startklass = mono_class_from_mono_type (D.30787);
      klass = startklass;
      D.30794 = reftype->type;
      refklass = mono_class_from_mono_type (D.30794);
      tmp_array.size = 0;
      tmp_array.capacity = 16;
      D.30795 = __builtin_alloca (128);
      tmp_array.data = D.30795;
      handle_parent:
      D.30796 = klass->exception_type;
      if (D.30796 != 0) goto <D.30797>; else goto <D.30798>;
      <D.30797>:
      D.30799 = tmp_array.capacity;
      if (D.30799 > 16) goto <D.30800>; else goto <D.30801>;
      <D.30800>:
      D.30802 = tmp_array.data;
      mono_gc_free_fixed (D.30802);
      <D.30801>:
      D.30803 = mono_class_get_exception_for_failure (klass);
      mono_raise_exception (D.30803);
      <D.30798>:
      iter = 0B;
      goto <D.22717>;
      <D.22719>:
      {
        guint32 flags;

        flags = mono_field_get_flags (field);
        match = 0;
        D.30804 = flags & 1536;
        if (D.30804 != 0) goto <D.30805>; else goto <D.30806>;
        <D.30805>:
        {
          size_t __s1_len;
          size_t __s2_len;

          __s2_len = 8;
          if (__s2_len <= 3) goto <D.30808>; else goto <D.30809>;
          <D.30808>:
          {
            const unsigned char * __s2;
            int __result;

            __s2 = mono_field_get_name (field);
            D.30810 = "_Deleted";
            D.30811 = MEM[(const unsigned char *)D.30810];
            D.30812 = (int) D.30811;
            D.30813 = *__s2;
            D.30814 = (int) D.30813;
            __result = D.30812 - D.30814;
            {
              if (__s2_len != 0) goto <D.30815>; else goto <D.30816>;
              <D.30815>:
              if (__result == 0) goto <D.30817>; else goto <D.30818>;
              <D.30817>:
              D.30819 = &MEM[(void *)"_Deleted" + 1B];
              D.30820 = *D.30819;
              D.30821 = (int) D.30820;
              D.30822 = __s2 + 1;
              D.30823 = *D.30822;
              D.30824 = (int) D.30823;
              __result = D.30821 - D.30824;
              if (__s2_len > 1) goto <D.30825>; else goto <D.30826>;
              <D.30825>:
              if (__result == 0) goto <D.30827>; else goto <D.30828>;
              <D.30827>:
              D.30829 = &MEM[(void *)"_Deleted" + 2B];
              D.30830 = *D.30829;
              D.30831 = (int) D.30830;
              D.30832 = __s2 + 2;
              D.30833 = *D.30832;
              D.30834 = (int) D.30833;
              __result = D.30831 - D.30834;
              if (__s2_len > 2) goto <D.30835>; else goto <D.30836>;
              <D.30835>:
              if (__result == 0) goto <D.30837>; else goto <D.30838>;
              <D.30837>:
              D.30839 = &MEM[(void *)"_Deleted" + 3B];
              D.30840 = *D.30839;
              D.30841 = (int) D.30840;
              D.30842 = __s2 + 3;
              D.30843 = *D.30842;
              D.30844 = (int) D.30843;
              __result = D.30841 - D.30844;
              <D.30838>:
              <D.30836>:
              <D.30828>:
              <D.30826>:
              <D.30818>:
              <D.30816>:
            }
            D.22715 = __result;
          }
          iftmp.157 = -D.22715;
          goto <D.30845>;
          <D.30809>:
          D.30846 = mono_field_get_name (field);
          iftmp.157 = __builtin_strcmp (D.30846, "_Deleted");
          <D.30845>:
          D.22716 = iftmp.157;
        }
        if (D.22716 == 0) goto <D.30847>; else goto <D.30848>;
        <D.30847>:
        // predicted unlikely by continue predictor.
        goto <D.22717>;
        <D.30848>:
        <D.30806>:
        D.30849 = flags & 7;
        if (D.30849 == 6) goto <D.30850>; else goto <D.30851>;
        <D.30850>:
        D.30852 = bflags & 16;
        if (D.30852 != 0) goto <D.30853>; else goto <D.30854>;
        <D.30853>:
        match = match + 1;
        <D.30854>:
        goto <D.30855>;
        <D.30851>:
        if (klass == startklass) goto <D.30856>; else goto <D.30858>;
        <D.30858>:
        D.30849 = flags & 7;
        if (D.30849 != 1) goto <D.30856>; else goto <D.30857>;
        <D.30856>:
        D.30859 = bflags & 32;
        if (D.30859 != 0) goto <D.30860>; else goto <D.30861>;
        <D.30860>:
        match = match + 1;
        <D.30861>:
        <D.30857>:
        <D.30855>:
        if (match == 0) goto <D.30862>; else goto <D.30863>;
        <D.30862>:
        // predicted unlikely by continue predictor.
        goto <D.22717>;
        <D.30863>:
        match = 0;
        D.30864 = flags & 16;
        if (D.30864 != 0) goto <D.30865>; else goto <D.30866>;
        <D.30865>:
        D.30867 = bflags & 8;
        if (D.30867 != 0) goto <D.30868>; else goto <D.30869>;
        <D.30868>:
        D.30872 = bflags & 64;
        if (D.30872 != 0) goto <D.30870>; else goto <D.30873>;
        <D.30873>:
        if (klass == startklass) goto <D.30870>; else goto <D.30871>;
        <D.30870>:
        match = match + 1;
        <D.30871>:
        <D.30869>:
        goto <D.30874>;
        <D.30866>:
        D.30875 = bflags & 4;
        if (D.30875 != 0) goto <D.30876>; else goto <D.30877>;
        <D.30876>:
        match = match + 1;
        <D.30877>:
        <D.30874>:
        if (match == 0) goto <D.30878>; else goto <D.30879>;
        <D.30878>:
        // predicted unlikely by continue predictor.
        goto <D.22717>;
        <D.30879>:
        member = mono_field_get_object (domain, refklass, field);
        D.30880 = tmp_array.size;
        D.30799 = tmp_array.capacity;
        if (D.30880 >= D.30799) goto <D.30881>; else goto <D.30882>;
        <D.30881>:
        {
          void * __tmp;

          D.30799 = tmp_array.capacity;
          D.30883 = (long unsigned int) D.30799;
          D.30884 = D.30883 * 16;
          D.30799 = tmp_array.capacity;
          D.30885 = D.30799 * 2;
          D.30886 = mono_gc_make_root_descr_all_refs (D.30885);
          __tmp = mono_gc_alloc_fixed (D.30884, D.30886);
          D.30802 = tmp_array.data;
          D.30799 = tmp_array.capacity;
          D.30883 = (long unsigned int) D.30799;
          D.30887 = D.30883 * 8;
          mono_gc_memmove_aligned (__tmp, D.30802, D.30887);
          D.30799 = tmp_array.capacity;
          if (D.30799 > 16) goto <D.30888>; else goto <D.30889>;
          <D.30888>:
          D.30802 = tmp_array.data;
          mono_gc_free_fixed (D.30802);
          <D.30889>:
          tmp_array.data = __tmp;
          D.30799 = tmp_array.capacity;
          D.30885 = D.30799 * 2;
          tmp_array.capacity = D.30885;
        }
        <D.30882>:
        D.30802 = tmp_array.data;
        D.30880 = tmp_array.size;
        D.30890 = D.30880;
        D.30891 = D.30890 + 1;
        tmp_array.size = D.30891;
        D.30892 = (long unsigned int) D.30890;
        D.30893 = D.30892 * 8;
        D.30894 = D.30802 + D.30893;
        *D.30894 = member;
      }
      <D.22717>:
      field = mono_class_get_fields_lazy (klass, &iter);
      if (field != 0B) goto <D.22719>; else goto <D.22720>;
      <D.22720>:
      D.30895 = bflags & 2;
      if (D.30895 == 0) goto <D.30896>; else goto <D.30897>;
      <D.30896>:
      klass = klass->parent;
      if (klass != 0B) goto handle_parent; else goto <D.30898>;
      <D.30898>:
      <D.30897>:
      {
        static struct MonoClass * tmp_klass;

        {
          tmp_klass.158 = tmp_klass;
          if (tmp_klass.158 == 0B) goto <D.30900>; else goto <D.30901>;
          <D.30900>:
          D.30793 = mono_defaults.field_info_class;
          tmp_klass.159 = mono_array_class_get (D.30793, 1);
          tmp_klass = tmp_klass.159;
          tmp_klass.158 = tmp_klass;
          D.30903 = tmp_klass.158 == 0B;
          D.30904 = (long int) D.30903;
          D.30905 = __builtin_expect (D.30904, 0);
          if (D.30905 != 0) goto <D.30906>; else goto <D.30907>;
          <D.30906>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "icall.c", 3414, "tmp_klass");
          <D.30907>:
          <D.30901>:
        }
        D.22722 = tmp_klass;
      }
      D.30908 = mono_class_vtable (domain, D.22722);
      D.30880 = tmp_array.size;
      D.30909 = (long unsigned int) D.30880;
      res = mono_array_new_specific (D.30908, D.30909);
      i = 0;
      goto <D.22725>;
      <D.22724>:
      {
        void * * __p;

        D.30910 = (long unsigned int) i;
        __p = mono_array_addr_with_size (res, 8, D.30910);
        D.30802 = tmp_array.data;
        D.30911 = (long unsigned int) i;
        D.30912 = D.30911 * 8;
        D.30913 = D.30802 + D.30912;
        D.30914 = *D.30913;
        mono_gc_wbarrier_set_arrayref (res, __p, D.30914);
      }
      i = i + 1;
      <D.22725>:
      D.30880 = tmp_array.size;
      if (D.30880 > i) goto <D.22724>; else goto <D.22726>;
      <D.22726>:
      D.30799 = tmp_array.capacity;
      if (D.30799 > 16) goto <D.30915>; else goto <D.30916>;
      <D.30915>:
      D.30802 = tmp_array.data;
      mono_gc_free_fixed (D.30802);
      <D.30916>:
      D.30792 = res;
      return D.30792;
    }
  finally
    {
      iter = {CLOBBER};
      tmp_array = {CLOBBER};
    }
}


ves_icall_Type_GetField (struct MonoReflectionType * type, struct MonoString * name, guint32 bflags)
{
  struct MonoVTable * D.30919;
  struct MonoType * D.30920;
  struct MonoException * D.30923;
  long unsigned int D.30924;
  long unsigned int D.30925;
  struct MonoReflectionField * D.30928;
  int (*<T3a56>) (const char *, const char *) iftmp.160;
  unsigned int D.30930;
  unsigned char D.30934;
  struct MonoException * D.30937;
  unsigned int D.30938;
  int D.22686;
  int iftmp.161;
  int D.22685;
  const char[9] * D.30944;
  unsigned char D.30945;
  int D.30946;
  unsigned char D.30947;
  int D.30948;
  const unsigned char * D.30953;
  unsigned char D.30954;
  int D.30955;
  const unsigned char * D.30956;
  unsigned char D.30957;
  int D.30958;
  const unsigned char * D.30963;
  unsigned char D.30964;
  int D.30965;
  const unsigned char * D.30966;
  unsigned char D.30967;
  int D.30968;
  const unsigned char * D.30973;
  unsigned char D.30974;
  int D.30975;
  const unsigned char * D.30976;
  unsigned char D.30977;
  int D.30978;
  const char * D.30980;
  unsigned int D.30983;
  unsigned int D.30986;
  unsigned int D.30993;
  unsigned int D.30998;
  unsigned int D.31001;
  unsigned int D.31006;
  unsigned int D.31009;
  const char * D.31014;
  int D.31015;
  unsigned int D.31018;
  struct MonoDomain * domain;
  struct MonoClass * startklass;
  struct MonoClass * klass;
  int match;
  struct MonoClassField * field;
  void * iter;
  char * utf8_name;
  int (*<T3a56>) (const char *, const char *) compare_func;
  void handle_parent = <<< error >>>;

  try
    {
      compare_func = 0B;
      D.30919 = MEM[(struct MonoObject *)type].vtable;
      domain = D.30919->domain;
      D.30920 = type->type;
      startklass = mono_class_from_mono_type (D.30920);
      klass = startklass;
      if (name == 0B) goto <D.30921>; else goto <D.30922>;
      <D.30921>:
      D.30923 = mono_get_exception_argument_null ("name");
      mono_raise_exception (D.30923);
      <D.30922>:
      D.30920 = type->type;
      D.30924 = BIT_FIELD_REF <*D.30920, 64, 64>;
      D.30925 = D.30924 & 1073741824;
      if (D.30925 != 0) goto <D.30926>; else goto <D.30927>;
      <D.30926>:
      D.30928 = 0B;
      return D.30928;
      <D.30927>:
      D.30930 = bflags & 1;
      if (D.30930 != 0) goto <D.30931>; else goto <D.30932>;
      <D.30931>:
      iftmp.160 = monoeg_ascii_strcasecmp;
      goto <D.30933>;
      <D.30932>:
      iftmp.160 = strcmp;
      <D.30933>:
      compare_func = iftmp.160;
      handle_parent:
      D.30934 = klass->exception_type;
      if (D.30934 != 0) goto <D.30935>; else goto <D.30936>;
      <D.30935>:
      D.30937 = mono_class_get_exception_for_failure (klass);
      mono_raise_exception (D.30937);
      <D.30936>:
      iter = 0B;
      goto <D.22687>;
      <D.22688>:
      {
        guint32 flags;

        flags = mono_field_get_flags (field);
        match = 0;
        D.30938 = flags & 1536;
        if (D.30938 != 0) goto <D.30939>; else goto <D.30940>;
        <D.30939>:
        {
          size_t __s1_len;
          size_t __s2_len;

          __s2_len = 8;
          if (__s2_len <= 3) goto <D.30942>; else goto <D.30943>;
          <D.30942>:
          {
            const unsigned char * __s2;
            int __result;

            __s2 = mono_field_get_name (field);
            D.30944 = "_Deleted";
            D.30945 = MEM[(const unsigned char *)D.30944];
            D.30946 = (int) D.30945;
            D.30947 = *__s2;
            D.30948 = (int) D.30947;
            __result = D.30946 - D.30948;
            {
              if (__s2_len != 0) goto <D.30949>; else goto <D.30950>;
              <D.30949>:
              if (__result == 0) goto <D.30951>; else goto <D.30952>;
              <D.30951>:
              D.30953 = &MEM[(void *)"_Deleted" + 1B];
              D.30954 = *D.30953;
              D.30955 = (int) D.30954;
              D.30956 = __s2 + 1;
              D.30957 = *D.30956;
              D.30958 = (int) D.30957;
              __result = D.30955 - D.30958;
              if (__s2_len > 1) goto <D.30959>; else goto <D.30960>;
              <D.30959>:
              if (__result == 0) goto <D.30961>; else goto <D.30962>;
              <D.30961>:
              D.30963 = &MEM[(void *)"_Deleted" + 2B];
              D.30964 = *D.30963;
              D.30965 = (int) D.30964;
              D.30966 = __s2 + 2;
              D.30967 = *D.30966;
              D.30968 = (int) D.30967;
              __result = D.30965 - D.30968;
              if (__s2_len > 2) goto <D.30969>; else goto <D.30970>;
              <D.30969>:
              if (__result == 0) goto <D.30971>; else goto <D.30972>;
              <D.30971>:
              D.30973 = &MEM[(void *)"_Deleted" + 3B];
              D.30974 = *D.30973;
              D.30975 = (int) D.30974;
              D.30976 = __s2 + 3;
              D.30977 = *D.30976;
              D.30978 = (int) D.30977;
              __result = D.30975 - D.30978;
              <D.30972>:
              <D.30970>:
              <D.30962>:
              <D.30960>:
              <D.30952>:
              <D.30950>:
            }
            D.22685 = __result;
          }
          iftmp.161 = -D.22685;
          goto <D.30979>;
          <D.30943>:
          D.30980 = mono_field_get_name (field);
          iftmp.161 = __builtin_strcmp (D.30980, "_Deleted");
          <D.30979>:
          D.22686 = iftmp.161;
        }
        if (D.22686 == 0) goto <D.30981>; else goto <D.30982>;
        <D.30981>:
        // predicted unlikely by continue predictor.
        goto <D.22687>;
        <D.30982>:
        <D.30940>:
        D.30983 = flags & 7;
        if (D.30983 == 6) goto <D.30984>; else goto <D.30985>;
        <D.30984>:
        D.30986 = bflags & 16;
        if (D.30986 != 0) goto <D.30987>; else goto <D.30988>;
        <D.30987>:
        match = match + 1;
        <D.30988>:
        goto <D.30989>;
        <D.30985>:
        if (klass == startklass) goto <D.30990>; else goto <D.30992>;
        <D.30992>:
        D.30983 = flags & 7;
        if (D.30983 != 1) goto <D.30990>; else goto <D.30991>;
        <D.30990>:
        D.30993 = bflags & 32;
        if (D.30993 != 0) goto <D.30994>; else goto <D.30995>;
        <D.30994>:
        match = match + 1;
        <D.30995>:
        <D.30991>:
        <D.30989>:
        if (match == 0) goto <D.30996>; else goto <D.30997>;
        <D.30996>:
        // predicted unlikely by continue predictor.
        goto <D.22687>;
        <D.30997>:
        match = 0;
        D.30998 = flags & 16;
        if (D.30998 != 0) goto <D.30999>; else goto <D.31000>;
        <D.30999>:
        D.31001 = bflags & 8;
        if (D.31001 != 0) goto <D.31002>; else goto <D.31003>;
        <D.31002>:
        D.31006 = bflags & 64;
        if (D.31006 != 0) goto <D.31004>; else goto <D.31007>;
        <D.31007>:
        if (klass == startklass) goto <D.31004>; else goto <D.31005>;
        <D.31004>:
        match = match + 1;
        <D.31005>:
        <D.31003>:
        goto <D.31008>;
        <D.31000>:
        D.31009 = bflags & 4;
        if (D.31009 != 0) goto <D.31010>; else goto <D.31011>;
        <D.31010>:
        match = match + 1;
        <D.31011>:
        <D.31008>:
        if (match == 0) goto <D.31012>; else goto <D.31013>;
        <D.31012>:
        // predicted unlikely by continue predictor.
        goto <D.22687>;
        <D.31013>:
        utf8_name = mono_string_to_utf8 (name);
        D.31014 = mono_field_get_name (field);
        D.31015 = compare_func (D.31014, utf8_name);
        if (D.31015 != 0) goto <D.31016>; else goto <D.31017>;
        <D.31016>:
        monoeg_g_free (utf8_name);
        // predicted unlikely by continue predictor.
        goto <D.22687>;
        <D.31017>:
        monoeg_g_free (utf8_name);
        D.30928 = mono_field_get_object (domain, klass, field);
        return D.30928;
      }
      <D.22687>:
      field = mono_class_get_fields_lazy (klass, &iter);
      if (field != 0B) goto <D.22688>; else goto <D.22689>;
      <D.22689>:
      D.31018 = bflags & 2;
      if (D.31018 == 0) goto <D.31019>; else goto <D.31020>;
      <D.31019>:
      klass = klass->parent;
      if (klass != 0B) goto handle_parent; else goto <D.31021>;
      <D.31021>:
      <D.31020>:
      D.30928 = 0B;
      return D.30928;
    }
  finally
    {
      iter = {CLOBBER};
    }
}


ves_icall_Type_GetEvents_internal (struct MonoReflectionType * type, guint32 bflags, struct MonoReflectionType * reftype)
{
  void * D.31024;
  struct MonoClass * System_Reflection_EventInfo.162;
  struct MonoImage * D.31028;
  struct MonoClass * System_Reflection_EventInfo.163;
  struct MonoVTable * D.31030;
  struct MonoType * D.31031;
  long unsigned int D.31032;
  long unsigned int D.31033;
  struct MonoArray * D.31036;
  struct MonoClass * D.22945;
  struct MonoClass * tmp_klass.164;
  struct MonoClass * tmp_klass.165;
  _Bool D.31041;
  long int D.31042;
  long int D.31043;
  struct MonoVTable * D.31046;
  unsigned char D.31047;
  struct MonoLoaderError * D.31049;
  short unsigned int D.31057;
  int D.31058;
  int D.31059;
  unsigned int D.31062;
  unsigned int D.31069;
  int D.31079;
  unsigned int D.31082;
  unsigned int D.31087;
  unsigned int D.31090;
  int D.31098;
  int D.31099;
  long unsigned int D.31102;
  long unsigned int D.31103;
  int D.31104;
  void * D.31105;
  void * * D.31106;
  long unsigned int D.31107;
  int D.31110;
  int D.31111;
  long unsigned int D.31112;
  long unsigned int D.31113;
  void * * D.31114;
  struct MonoReflectionEvent * D.31115;
  unsigned int D.31116;
  struct MonoClass * D.22953;
  struct MonoClass * tmp_klass.166;
  struct MonoClass * tmp_klass.167;
  _Bool D.31124;
  long int D.31125;
  long int D.31126;
  struct MonoVTable * D.31129;
  long unsigned int D.31130;
  long unsigned int D.31131;
  long unsigned int D.31132;
  long unsigned int D.31133;
  void * * D.31134;
  void * D.31135;
  struct MonoLoaderError * D.31143;
  struct MonoException * ex;
  struct MonoDomain * domain;
  static struct MonoClass * System_Reflection_EventInfo;
  struct MonoClass * startklass;
  struct MonoClass * klass;
  struct MonoArray * res;
  struct MonoMethod * method;
  struct MonoEvent * event;
  int i;
  int match;
  void * iter;
  struct MonoPtrArray tmp_array;
  void handle_parent = <<< error >>>;
  void loader_error = <<< error >>>;

  try
    {
      tmp_array.size = 0;
      tmp_array.capacity = 16;
      D.31024 = __builtin_alloca (128);
      tmp_array.data = D.31024;
      System_Reflection_EventInfo.162 = System_Reflection_EventInfo;
      if (System_Reflection_EventInfo.162 == 0B) goto <D.31026>; else goto <D.31027>;
      <D.31026>:
      D.31028 = mono_defaults.corlib;
      System_Reflection_EventInfo.163 = mono_class_from_name (D.31028, "System.Reflection", "EventInfo");
      System_Reflection_EventInfo = System_Reflection_EventInfo.163;
      <D.31027>:
      D.31030 = MEM[(struct MonoObject *)type].vtable;
      domain = D.31030->domain;
      D.31031 = type->type;
      D.31032 = BIT_FIELD_REF <*D.31031, 64, 64>;
      D.31033 = D.31032 & 1073741824;
      if (D.31033 != 0) goto <D.31034>; else goto <D.31035>;
      <D.31034>:
      {
        static struct MonoClass * tmp_klass;

        {
          tmp_klass.164 = tmp_klass;
          if (tmp_klass.164 == 0B) goto <D.31038>; else goto <D.31039>;
          <D.31038>:
          System_Reflection_EventInfo.162 = System_Reflection_EventInfo;
          tmp_klass.165 = mono_array_class_get (System_Reflection_EventInfo.162, 1);
          tmp_klass = tmp_klass.165;
          tmp_klass.164 = tmp_klass;
          D.31041 = tmp_klass.164 == 0B;
          D.31042 = (long int) D.31041;
          D.31043 = __builtin_expect (D.31042, 0);
          if (D.31043 != 0) goto <D.31044>; else goto <D.31045>;
          <D.31044>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "icall.c", 3914, "tmp_klass");
          <D.31045>:
          <D.31039>:
        }
        D.22945 = tmp_klass;
      }
      D.31046 = mono_class_vtable (domain, D.22945);
      D.31036 = mono_array_new_specific (D.31046, 0);
      return D.31036;
      <D.31035>:
      D.31031 = type->type;
      startklass = mono_class_from_mono_type (D.31031);
      klass = startklass;
      handle_parent:
      mono_class_setup_vtable (klass);
      D.31047 = klass->exception_type;
      if (D.31047 != 0) goto loader_error; else goto <D.31048>;
      <D.31048>:
      D.31049 = mono_loader_get_last_error ();
      if (D.31049 != 0B) goto loader_error; else goto <D.31050>;
      <D.31050>:
      iter = 0B;
      goto <D.22948>;
      <D.22950>:
      match = 0;
      method = event->add;
      if (method == 0B) goto <D.31051>; else goto <D.31052>;
      <D.31051>:
      method = event->remove;
      <D.31052>:
      if (method == 0B) goto <D.31053>; else goto <D.31054>;
      <D.31053>:
      method = event->raise;
      <D.31054>:
      if (method != 0B) goto <D.31055>; else goto <D.31056>;
      <D.31055>:
      D.31057 = method->flags;
      D.31058 = (int) D.31057;
      D.31059 = D.31058 & 7;
      if (D.31059 == 6) goto <D.31060>; else goto <D.31061>;
      <D.31060>:
      D.31062 = bflags & 16;
      if (D.31062 != 0) goto <D.31063>; else goto <D.31064>;
      <D.31063>:
      match = match + 1;
      <D.31064>:
      goto <D.31065>;
      <D.31061>:
      if (klass == startklass) goto <D.31066>; else goto <D.31068>;
      <D.31068>:
      D.31057 = method->flags;
      D.31058 = (int) D.31057;
      D.31059 = D.31058 & 7;
      if (D.31059 != 1) goto <D.31066>; else goto <D.31067>;
      <D.31066>:
      D.31069 = bflags & 32;
      if (D.31069 != 0) goto <D.31070>; else goto <D.31071>;
      <D.31070>:
      match = match + 1;
      <D.31071>:
      <D.31067>:
      <D.31065>:
      goto <D.31072>;
      <D.31056>:
      D.31069 = bflags & 32;
      if (D.31069 != 0) goto <D.31073>; else goto <D.31074>;
      <D.31073>:
      match = match + 1;
      <D.31074>:
      <D.31072>:
      if (match == 0) goto <D.31075>; else goto <D.31076>;
      <D.31075>:
      // predicted unlikely by continue predictor.
      goto <D.22948>;
      <D.31076>:
      match = 0;
      if (method != 0B) goto <D.31077>; else goto <D.31078>;
      <D.31077>:
      D.31057 = method->flags;
      D.31058 = (int) D.31057;
      D.31079 = D.31058 & 16;
      if (D.31079 != 0) goto <D.31080>; else goto <D.31081>;
      <D.31080>:
      D.31082 = bflags & 8;
      if (D.31082 != 0) goto <D.31083>; else goto <D.31084>;
      <D.31083>:
      D.31087 = bflags & 64;
      if (D.31087 != 0) goto <D.31085>; else goto <D.31088>;
      <D.31088>:
      if (klass == startklass) goto <D.31085>; else goto <D.31086>;
      <D.31085>:
      match = match + 1;
      <D.31086>:
      <D.31084>:
      goto <D.31089>;
      <D.31081>:
      D.31090 = bflags & 4;
      if (D.31090 != 0) goto <D.31091>; else goto <D.31092>;
      <D.31091>:
      match = match + 1;
      <D.31092>:
      <D.31089>:
      goto <D.31093>;
      <D.31078>:
      D.31090 = bflags & 4;
      if (D.31090 != 0) goto <D.31094>; else goto <D.31095>;
      <D.31094>:
      match = match + 1;
      <D.31095>:
      <D.31093>:
      if (match == 0) goto <D.31096>; else goto <D.31097>;
      <D.31096>:
      // predicted unlikely by continue predictor.
      goto <D.22948>;
      <D.31097>:
      D.31098 = tmp_array.size;
      D.31099 = tmp_array.capacity;
      if (D.31098 >= D.31099) goto <D.31100>; else goto <D.31101>;
      <D.31100>:
      {
        void * __tmp;

        D.31099 = tmp_array.capacity;
        D.31102 = (long unsigned int) D.31099;
        D.31103 = D.31102 * 16;
        D.31099 = tmp_array.capacity;
        D.31104 = D.31099 * 2;
        D.31105 = mono_gc_make_root_descr_all_refs (D.31104);
        __tmp = mono_gc_alloc_fixed (D.31103, D.31105);
        D.31106 = tmp_array.data;
        D.31099 = tmp_array.capacity;
        D.31102 = (long unsigned int) D.31099;
        D.31107 = D.31102 * 8;
        mono_gc_memmove_aligned (__tmp, D.31106, D.31107);
        D.31099 = tmp_array.capacity;
        if (D.31099 > 16) goto <D.31108>; else goto <D.31109>;
        <D.31108>:
        D.31106 = tmp_array.data;
        mono_gc_free_fixed (D.31106);
        <D.31109>:
        tmp_array.data = __tmp;
        D.31099 = tmp_array.capacity;
        D.31104 = D.31099 * 2;
        tmp_array.capacity = D.31104;
      }
      <D.31101>:
      D.31106 = tmp_array.data;
      D.31098 = tmp_array.size;
      D.31110 = D.31098;
      D.31111 = D.31110 + 1;
      tmp_array.size = D.31111;
      D.31112 = (long unsigned int) D.31110;
      D.31113 = D.31112 * 8;
      D.31114 = D.31106 + D.31113;
      D.31115 = mono_event_get_object (domain, startklass, event);
      *D.31114 = D.31115;
      <D.22948>:
      event = mono_class_get_events (klass, &iter);
      if (event != 0B) goto <D.22950>; else goto <D.22951>;
      <D.22951>:
      D.31116 = bflags & 2;
      if (D.31116 == 0) goto <D.31117>; else goto <D.31118>;
      <D.31117>:
      klass = klass->parent;
      if (klass != 0B) goto handle_parent; else goto <D.31119>;
      <D.31119>:
      <D.31118>:
      {
        static struct MonoClass * tmp_klass;

        {
          tmp_klass.166 = tmp_klass;
          if (tmp_klass.166 == 0B) goto <D.31121>; else goto <D.31122>;
          <D.31121>:
          System_Reflection_EventInfo.162 = System_Reflection_EventInfo;
          tmp_klass.167 = mono_array_class_get (System_Reflection_EventInfo.162, 1);
          tmp_klass = tmp_klass.167;
          tmp_klass.166 = tmp_klass;
          D.31124 = tmp_klass.166 == 0B;
          D.31125 = (long int) D.31124;
          D.31126 = __builtin_expect (D.31125, 0);
          if (D.31126 != 0) goto <D.31127>; else goto <D.31128>;
          <D.31127>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "icall.c", 3965, "tmp_klass");
          <D.31128>:
          <D.31122>:
        }
        D.22953 = tmp_klass;
      }
      D.31129 = mono_class_vtable (domain, D.22953);
      D.31098 = tmp_array.size;
      D.31130 = (long unsigned int) D.31098;
      res = mono_array_new_specific (D.31129, D.31130);
      i = 0;
      goto <D.22956>;
      <D.22955>:
      {
        void * * __p;

        D.31131 = (long unsigned int) i;
        __p = mono_array_addr_with_size (res, 8, D.31131);
        D.31106 = tmp_array.data;
        D.31132 = (long unsigned int) i;
        D.31133 = D.31132 * 8;
        D.31134 = D.31106 + D.31133;
        D.31135 = *D.31134;
        mono_gc_wbarrier_set_arrayref (res, __p, D.31135);
      }
      i = i + 1;
      <D.22956>:
      D.31098 = tmp_array.size;
      if (D.31098 > i) goto <D.22955>; else goto <D.22957>;
      <D.22957>:
      D.31099 = tmp_array.capacity;
      if (D.31099 > 16) goto <D.31136>; else goto <D.31137>;
      <D.31136>:
      D.31106 = tmp_array.data;
      mono_gc_free_fixed (D.31106);
      <D.31137>:
      D.31036 = res;
      return D.31036;
      loader_error:
      D.31099 = tmp_array.capacity;
      if (D.31099 > 16) goto <D.31138>; else goto <D.31139>;
      <D.31138>:
      D.31106 = tmp_array.data;
      mono_gc_free_fixed (D.31106);
      <D.31139>:
      D.31047 = klass->exception_type;
      if (D.31047 != 0) goto <D.31140>; else goto <D.31141>;
      <D.31140>:
      ex = mono_class_get_exception_for_failure (klass);
      goto <D.31142>;
      <D.31141>:
      D.31143 = mono_loader_get_last_error ();
      ex = mono_loader_error_prepare_exception (D.31143);
      mono_loader_clear_error ();
      <D.31142>:
      mono_raise_exception (ex);
      D.31036 = 0B;
      return D.31036;
    }
  finally
    {
      iter = {CLOBBER};
      tmp_array = {CLOBBER};
    }
}


ves_icall_MonoType_GetElementType (struct MonoReflectionType * type)
{
  struct MonoType * D.31146;
  long unsigned int D.31147;
  long unsigned int D.31148;
  struct MonoReflectionType * D.31151;
  struct MonoVTable * D.31152;
  struct MonoDomain * D.31153;
  struct MonoClass * D.31154;
  struct MonoType * D.31155;
  long unsigned int D.31156;
  struct MonoType * D.31159;
  struct MonoClass * D.31161;
  unsigned char D.31163;
  struct MonoType * D.31165;
  unsigned char D.31168;
  struct MonoClass * class;

  D.31146 = type->type;
  D.31147 = BIT_FIELD_REF <*D.31146, 64, 64>;
  D.31148 = D.31147 & 1090453504;
  if (D.31148 == 1900544) goto <D.31149>; else goto <D.31150>;
  <D.31149>:
  D.31152 = MEM[(struct MonoObject *)type].vtable;
  D.31153 = D.31152->domain;
  D.31146 = type->type;
  D.31154 = D.31146->data.klass;
  D.31155 = &D.31154->byval_arg;
  D.31151 = mono_type_get_object (D.31153, D.31155);
  return D.31151;
  <D.31150>:
  D.31146 = type->type;
  class = mono_class_from_mono_type (D.31146);
  mono_class_init_or_throw (class);
  D.31146 = type->type;
  D.31147 = BIT_FIELD_REF <*D.31146, 64, 64>;
  D.31156 = D.31147 & 1073741824;
  if (D.31156 != 0) goto <D.31157>; else goto <D.31158>;
  <D.31157>:
  D.31152 = MEM[(struct MonoObject *)type].vtable;
  D.31153 = D.31152->domain;
  D.31159 = &class->byval_arg;
  D.31151 = mono_type_get_object (D.31153, D.31159);
  return D.31151;
  <D.31158>:
  D.31161 = class->element_class;
  if (D.31161 != 0B) goto <D.31162>; else goto <D.31160>;
  <D.31162>:
  D.31163 = class->rank;
  if (D.31163 != 0) goto <D.31164>; else goto <D.31160>;
  <D.31164>:
  D.31152 = MEM[(struct MonoObject *)type].vtable;
  D.31153 = D.31152->domain;
  D.31161 = class->element_class;
  D.31165 = &D.31161->byval_arg;
  D.31151 = mono_type_get_object (D.31153, D.31165);
  return D.31151;
  <D.31160>:
  D.31161 = class->element_class;
  if (D.31161 != 0B) goto <D.31167>; else goto <D.31166>;
  <D.31167>:
  D.31146 = type->type;
  D.31168 = D.31146->type;
  if (D.31168 == 15) goto <D.31169>; else goto <D.31166>;
  <D.31169>:
  D.31152 = MEM[(struct MonoObject *)type].vtable;
  D.31153 = D.31152->domain;
  D.31161 = class->element_class;
  D.31165 = &D.31161->byval_arg;
  D.31151 = mono_type_get_object (D.31153, D.31165);
  return D.31151;
  <D.31166>:
  D.31151 = 0B;
  return D.31151;
}


ves_icall_MonoType_GetCorrespondingInflatedMethod (struct MonoReflectionType * type, struct MonoReflectionMethod * generic)
{
  struct MonoVTable * D.31171;
  struct MonoType * D.31172;
  unsigned int D.31173;
  struct MonoMethod * D.31174;
  unsigned int D.31175;
  struct MonoReflectionMethod * D.31178;
  struct MonoDomain * domain;
  struct MonoClass * klass;
  struct MonoMethod * method;
  void * iter;

  try
    {
      D.31171 = MEM[(struct MonoObject *)type].vtable;
      domain = D.31171->domain;
      D.31172 = type->type;
      klass = mono_class_from_mono_type (D.31172);
      mono_class_init_or_throw (klass);
      iter = 0B;
      goto <D.22311>;
      <D.22310>:
      D.31173 = method->token;
      D.31174 = generic->method;
      D.31175 = D.31174->token;
      if (D.31173 == D.31175) goto <D.31176>; else goto <D.31177>;
      <D.31176>:
      D.31178 = mono_method_get_object (domain, method, klass);
      return D.31178;
      <D.31177>:
      <D.22311>:
      method = mono_class_get_methods (klass, &iter);
      if (method != 0B) goto <D.22310>; else goto <D.22312>;
      <D.22312>:
      D.31178 = 0B;
      return D.31178;
    }
  finally
    {
      iter = {CLOBBER};
    }
}


ves_icall_Type_GetConstructors_internal (struct MonoReflectionType * type, guint32 bflags, struct MonoReflectionType * reftype)
{
  void * D.31181;
  struct MonoVTable * D.31182;
  struct MonoType * D.31183;
  long unsigned int D.31184;
  long unsigned int D.31185;
  struct MonoArray * D.31188;
  struct MonoClass * D.22828;
  struct MonoClass * tmp_klass.168;
  struct MonoClass * D.31192;
  struct MonoClass * tmp_klass.169;
  _Bool D.31194;
  long int D.31195;
  long int D.31196;
  struct MonoVTable * D.31199;
  struct MonoType * D.31200;
  struct MonoClass * System_Reflection_ConstructorInfo.170;
  struct MonoImage * D.31204;
  struct MonoClass * System_Reflection_ConstructorInfo.171;
  int D.22837;
  int iftmp.172;
  int D.22836;
  const char[6] * D.31209;
  unsigned char D.31210;
  int D.31211;
  unsigned char D.31212;
  int D.31213;
  const unsigned char * D.31218;
  unsigned char D.31219;
  int D.31220;
  const unsigned char * D.31221;
  unsigned char D.31222;
  int D.31223;
  const unsigned char * D.31228;
  unsigned char D.31229;
  int D.31230;
  const unsigned char * D.31231;
  unsigned char D.31232;
  int D.31233;
  const unsigned char * D.31238;
  unsigned char D.31239;
  int D.31240;
  const unsigned char * D.31241;
  unsigned char D.31242;
  int D.31243;
  const char * D.31245;
  int D.22846;
  int iftmp.173;
  int D.22845;
  const char[7] * D.31251;
  unsigned char D.31252;
  int D.31253;
  unsigned char D.31254;
  int D.31255;
  const unsigned char * D.31260;
  unsigned char D.31261;
  int D.31262;
  const unsigned char * D.31263;
  unsigned char D.31264;
  int D.31265;
  const unsigned char * D.31270;
  unsigned char D.31271;
  int D.31272;
  const unsigned char * D.31273;
  unsigned char D.31274;
  int D.31275;
  const unsigned char * D.31280;
  unsigned char D.31281;
  int D.31282;
  const unsigned char * D.31283;
  unsigned char D.31284;
  int D.31285;
  short unsigned int D.31289;
  int D.31290;
  int D.31291;
  unsigned int D.31294;
  unsigned int D.31298;
  int D.31303;
  unsigned int D.31306;
  unsigned int D.31311;
  unsigned int D.31314;
  int D.31319;
  int D.31320;
  long unsigned int D.31323;
  long unsigned int D.31324;
  int D.31325;
  void * D.31326;
  void * * D.31327;
  long unsigned int D.31328;
  int D.31331;
  int D.31332;
  long unsigned int D.31333;
  long unsigned int D.31334;
  void * * D.31335;
  struct MonoClass * D.22852;
  struct MonoClass * tmp_klass.174;
  struct MonoClass * tmp_klass.175;
  _Bool D.31340;
  long int D.31341;
  long int D.31342;
  struct MonoVTable * D.31345;
  long unsigned int D.31346;
  long unsigned int D.31347;
  long unsigned int D.31348;
  long unsigned int D.31349;
  void * * D.31350;
  void * D.31351;
  struct MonoDomain * domain;
  static struct MonoClass * System_Reflection_ConstructorInfo;
  struct MonoClass * startklass;
  struct MonoClass * klass;
  struct MonoClass * refklass;
  struct MonoArray * res;
  struct MonoMethod * method;
  struct MonoObject * member;
  int i;
  int match;
  void * iter;
  struct MonoPtrArray tmp_array;

  try
    {
      iter = 0B;
      tmp_array.size = 0;
      tmp_array.capacity = 16;
      D.31181 = __builtin_alloca (128);
      tmp_array.data = D.31181;
      D.31182 = MEM[(struct MonoObject *)type].vtable;
      domain = D.31182->domain;
      D.31183 = type->type;
      D.31184 = BIT_FIELD_REF <*D.31183, 64, 64>;
      D.31185 = D.31184 & 1073741824;
      if (D.31185 != 0) goto <D.31186>; else goto <D.31187>;
      <D.31186>:
      {
        static struct MonoClass * tmp_klass;

        {
          tmp_klass.168 = tmp_klass;
          if (tmp_klass.168 == 0B) goto <D.31190>; else goto <D.31191>;
          <D.31190>:
          D.31192 = mono_defaults.method_info_class;
          tmp_klass.169 = mono_array_class_get (D.31192, 1);
          tmp_klass = tmp_klass.169;
          tmp_klass.168 = tmp_klass;
          D.31194 = tmp_klass.168 == 0B;
          D.31195 = (long int) D.31194;
          D.31196 = __builtin_expect (D.31195, 0);
          if (D.31196 != 0) goto <D.31197>; else goto <D.31198>;
          <D.31197>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "icall.c", 3617, "tmp_klass");
          <D.31198>:
          <D.31191>:
        }
        D.22828 = tmp_klass;
      }
      D.31199 = mono_class_vtable (domain, D.22828);
      D.31188 = mono_array_new_specific (D.31199, 0);
      return D.31188;
      <D.31187>:
      D.31183 = type->type;
      startklass = mono_class_from_mono_type (D.31183);
      klass = startklass;
      D.31200 = reftype->type;
      refklass = mono_class_from_mono_type (D.31200);
      System_Reflection_ConstructorInfo.170 = System_Reflection_ConstructorInfo;
      if (System_Reflection_ConstructorInfo.170 == 0B) goto <D.31202>; else goto <D.31203>;
      <D.31202>:
      D.31204 = mono_defaults.corlib;
      System_Reflection_ConstructorInfo.171 = mono_class_from_name (D.31204, "System.Reflection", "ConstructorInfo");
      System_Reflection_ConstructorInfo = System_Reflection_ConstructorInfo.171;
      <D.31203>:
      iter = 0B;
      goto <D.22847>;
      <D.22849>:
      match = 0;
      {
        size_t __s1_len;
        size_t __s2_len;

        __s2_len = 5;
        if (__s2_len <= 3) goto <D.31207>; else goto <D.31208>;
        <D.31207>:
        {
          const unsigned char * __s2;
          int __result;

          __s2 = method->name;
          D.31209 = ".ctor";
          D.31210 = MEM[(const unsigned char *)D.31209];
          D.31211 = (int) D.31210;
          D.31212 = *__s2;
          D.31213 = (int) D.31212;
          __result = D.31211 - D.31213;
          {
            if (__s2_len != 0) goto <D.31214>; else goto <D.31215>;
            <D.31214>:
            if (__result == 0) goto <D.31216>; else goto <D.31217>;
            <D.31216>:
            D.31218 = &MEM[(void *)".ctor" + 1B];
            D.31219 = *D.31218;
            D.31220 = (int) D.31219;
            D.31221 = __s2 + 1;
            D.31222 = *D.31221;
            D.31223 = (int) D.31222;
            __result = D.31220 - D.31223;
            if (__s2_len > 1) goto <D.31224>; else goto <D.31225>;
            <D.31224>:
            if (__result == 0) goto <D.31226>; else goto <D.31227>;
            <D.31226>:
            D.31228 = &MEM[(void *)".ctor" + 2B];
            D.31229 = *D.31228;
            D.31230 = (int) D.31229;
            D.31231 = __s2 + 2;
            D.31232 = *D.31231;
            D.31233 = (int) D.31232;
            __result = D.31230 - D.31233;
            if (__s2_len > 2) goto <D.31234>; else goto <D.31235>;
            <D.31234>:
            if (__result == 0) goto <D.31236>; else goto <D.31237>;
            <D.31236>:
            D.31238 = &MEM[(void *)".ctor" + 3B];
            D.31239 = *D.31238;
            D.31240 = (int) D.31239;
            D.31241 = __s2 + 3;
            D.31242 = *D.31241;
            D.31243 = (int) D.31242;
            __result = D.31240 - D.31243;
            <D.31237>:
            <D.31235>:
            <D.31227>:
            <D.31225>:
            <D.31217>:
            <D.31215>:
          }
          D.22836 = __result;
        }
        iftmp.172 = -D.22836;
        goto <D.31244>;
        <D.31208>:
        D.31245 = method->name;
        iftmp.172 = __builtin_strcmp (D.31245, ".ctor");
        <D.31244>:
        D.22837 = iftmp.172;
      }
      if (D.22837 != 0) goto <D.31246>; else goto <D.31247>;
      <D.31246>:
      {
        size_t __s1_len;
        size_t __s2_len;

        __s2_len = 6;
        if (__s2_len <= 3) goto <D.31249>; else goto <D.31250>;
        <D.31249>:
        {
          const unsigned char * __s2;
          int __result;

          __s2 = method->name;
          D.31251 = ".cctor";
          D.31252 = MEM[(const unsigned char *)D.31251];
          D.31253 = (int) D.31252;
          D.31254 = *__s2;
          D.31255 = (int) D.31254;
          __result = D.31253 - D.31255;
          {
            if (__s2_len != 0) goto <D.31256>; else goto <D.31257>;
            <D.31256>:
            if (__result == 0) goto <D.31258>; else goto <D.31259>;
            <D.31258>:
            D.31260 = &MEM[(void *)".cctor" + 1B];
            D.31261 = *D.31260;
            D.31262 = (int) D.31261;
            D.31263 = __s2 + 1;
            D.31264 = *D.31263;
            D.31265 = (int) D.31264;
            __result = D.31262 - D.31265;
            if (__s2_len > 1) goto <D.31266>; else goto <D.31267>;
            <D.31266>:
            if (__result == 0) goto <D.31268>; else goto <D.31269>;
            <D.31268>:
            D.31270 = &MEM[(void *)".cctor" + 2B];
            D.31271 = *D.31270;
            D.31272 = (int) D.31271;
            D.31273 = __s2 + 2;
            D.31274 = *D.31273;
            D.31275 = (int) D.31274;
            __result = D.31272 - D.31275;
            if (__s2_len > 2) goto <D.31276>; else goto <D.31277>;
            <D.31276>:
            if (__result == 0) goto <D.31278>; else goto <D.31279>;
            <D.31278>:
            D.31280 = &MEM[(void *)".cctor" + 3B];
            D.31281 = *D.31280;
            D.31282 = (int) D.31281;
            D.31283 = __s2 + 3;
            D.31284 = *D.31283;
            D.31285 = (int) D.31284;
            __result = D.31282 - D.31285;
            <D.31279>:
            <D.31277>:
            <D.31269>:
            <D.31267>:
            <D.31259>:
            <D.31257>:
          }
          D.22845 = __result;
        }
        iftmp.173 = -D.22845;
        goto <D.31286>;
        <D.31250>:
        D.31245 = method->name;
        iftmp.173 = __builtin_strcmp (D.31245, ".cctor");
        <D.31286>:
        D.22846 = iftmp.173;
      }
      if (D.22846 != 0) goto <D.31287>; else goto <D.31288>;
      <D.31287>:
      // predicted unlikely by continue predictor.
      goto <D.22847>;
      <D.31288>:
      <D.31247>:
      D.31289 = method->flags;
      D.31290 = (int) D.31289;
      D.31291 = D.31290 & 7;
      if (D.31291 == 6) goto <D.31292>; else goto <D.31293>;
      <D.31292>:
      D.31294 = bflags & 16;
      if (D.31294 != 0) goto <D.31295>; else goto <D.31296>;
      <D.31295>:
      match = match + 1;
      <D.31296>:
      goto <D.31297>;
      <D.31293>:
      D.31298 = bflags & 32;
      if (D.31298 != 0) goto <D.31299>; else goto <D.31300>;
      <D.31299>:
      match = match + 1;
      <D.31300>:
      <D.31297>:
      if (match == 0) goto <D.31301>; else goto <D.31302>;
      <D.31301>:
      // predicted unlikely by continue predictor.
      goto <D.22847>;
      <D.31302>:
      match = 0;
      D.31289 = method->flags;
      D.31290 = (int) D.31289;
      D.31303 = D.31290 & 16;
      if (D.31303 != 0) goto <D.31304>; else goto <D.31305>;
      <D.31304>:
      D.31306 = bflags & 8;
      if (D.31306 != 0) goto <D.31307>; else goto <D.31308>;
      <D.31307>:
      D.31311 = bflags & 64;
      if (D.31311 != 0) goto <D.31309>; else goto <D.31312>;
      <D.31312>:
      if (klass == startklass) goto <D.31309>; else goto <D.31310>;
      <D.31309>:
      match = match + 1;
      <D.31310>:
      <D.31308>:
      goto <D.31313>;
      <D.31305>:
      D.31314 = bflags & 4;
      if (D.31314 != 0) goto <D.31315>; else goto <D.31316>;
      <D.31315>:
      match = match + 1;
      <D.31316>:
      <D.31313>:
      if (match == 0) goto <D.31317>; else goto <D.31318>;
      <D.31317>:
      // predicted unlikely by continue predictor.
      goto <D.22847>;
      <D.31318>:
      member = mono_method_get_object (domain, method, refklass);
      D.31319 = tmp_array.size;
      D.31320 = tmp_array.capacity;
      if (D.31319 >= D.31320) goto <D.31321>; else goto <D.31322>;
      <D.31321>:
      {
        void * __tmp;

        D.31320 = tmp_array.capacity;
        D.31323 = (long unsigned int) D.31320;
        D.31324 = D.31323 * 16;
        D.31320 = tmp_array.capacity;
        D.31325 = D.31320 * 2;
        D.31326 = mono_gc_make_root_descr_all_refs (D.31325);
        __tmp = mono_gc_alloc_fixed (D.31324, D.31326);
        D.31327 = tmp_array.data;
        D.31320 = tmp_array.capacity;
        D.31323 = (long unsigned int) D.31320;
        D.31328 = D.31323 * 8;
        mono_gc_memmove_aligned (__tmp, D.31327, D.31328);
        D.31320 = tmp_array.capacity;
        if (D.31320 > 16) goto <D.31329>; else goto <D.31330>;
        <D.31329>:
        D.31327 = tmp_array.data;
        mono_gc_free_fixed (D.31327);
        <D.31330>:
        tmp_array.data = __tmp;
        D.31320 = tmp_array.capacity;
        D.31325 = D.31320 * 2;
        tmp_array.capacity = D.31325;
      }
      <D.31322>:
      D.31327 = tmp_array.data;
      D.31319 = tmp_array.size;
      D.31331 = D.31319;
      D.31332 = D.31331 + 1;
      tmp_array.size = D.31332;
      D.31333 = (long unsigned int) D.31331;
      D.31334 = D.31333 * 8;
      D.31335 = D.31327 + D.31334;
      *D.31335 = member;
      <D.22847>:
      method = mono_class_get_methods (klass, &iter);
      if (method != 0B) goto <D.22849>; else goto <D.22850>;
      <D.22850>:
      {
        static struct MonoClass * tmp_klass;

        {
          tmp_klass.174 = tmp_klass;
          if (tmp_klass.174 == 0B) goto <D.31337>; else goto <D.31338>;
          <D.31337>:
          System_Reflection_ConstructorInfo.170 = System_Reflection_ConstructorInfo;
          tmp_klass.175 = mono_array_class_get (System_Reflection_ConstructorInfo.170, 1);
          tmp_klass = tmp_klass.175;
          tmp_klass.174 = tmp_klass;
          D.31340 = tmp_klass.174 == 0B;
          D.31341 = (long int) D.31340;
          D.31342 = __builtin_expect (D.31341, 0);
          if (D.31342 != 0) goto <D.31343>; else goto <D.31344>;
          <D.31343>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "icall.c", 3656, "tmp_klass");
          <D.31344>:
          <D.31338>:
        }
        D.22852 = tmp_klass;
      }
      D.31345 = mono_class_vtable (domain, D.22852);
      D.31319 = tmp_array.size;
      D.31346 = (long unsigned int) D.31319;
      res = mono_array_new_specific (D.31345, D.31346);
      i = 0;
      goto <D.22855>;
      <D.22854>:
      {
        void * * __p;

        D.31347 = (long unsigned int) i;
        __p = mono_array_addr_with_size (res, 8, D.31347);
        D.31327 = tmp_array.data;
        D.31348 = (long unsigned int) i;
        D.31349 = D.31348 * 8;
        D.31350 = D.31327 + D.31349;
        D.31351 = *D.31350;
        mono_gc_wbarrier_set_arrayref (res, __p, D.31351);
      }
      i = i + 1;
      <D.22855>:
      D.31319 = tmp_array.size;
      if (D.31319 > i) goto <D.22854>; else goto <D.22856>;
      <D.22856>:
      D.31320 = tmp_array.capacity;
      if (D.31320 > 16) goto <D.31352>; else goto <D.31353>;
      <D.31352>:
      D.31327 = tmp_array.data;
      mono_gc_free_fixed (D.31327);
      <D.31353>:
      D.31188 = res;
      return D.31188;
    }
  finally
    {
      iter = {CLOBBER};
      tmp_array = {CLOBBER};
    }
}


ves_icall_MonoType_GetArrayRank (struct MonoReflectionType * type)
{
  struct MonoType * D.31356;
  unsigned char D.31357;
  struct MonoException * D.31362;
  gint32 D.31363;
  unsigned char D.31364;
  struct MonoClass * class;

  D.31356 = type->type;
  D.31357 = D.31356->type;
  if (D.31357 != 20) goto <D.31358>; else goto <D.31359>;
  <D.31358>:
  D.31356 = type->type;
  D.31357 = D.31356->type;
  if (D.31357 != 29) goto <D.31360>; else goto <D.31361>;
  <D.31360>:
  D.31362 = mono_get_exception_argument ("type", "Type must be an array type");
  mono_raise_exception (D.31362);
  <D.31361>:
  <D.31359>:
  D.31356 = type->type;
  class = mono_class_from_mono_type (D.31356);
  D.31364 = class->rank;
  D.31363 = (gint32) D.31364;
  return D.31363;
}


ves_icall_get_enum_info (struct MonoReflectionType * type, struct MonoEnumInfo * info)
{
  struct MonoVTable * D.31366;
  struct MonoType * D.31367;
  struct MonoReflectionType * * D.31368;
  struct MonoType * D.31369;
  struct MonoReflectionType * D.31370;
  guint iftmp.176;
  int D.31372;
  int D.31375;
  int D.31376;
  struct MonoArray * * D.31378;
  struct MonoClass * D.31379;
  long unsigned int D.31380;
  struct MonoArray * D.31381;
  struct MonoArray * * D.31382;
  struct MonoArray * D.31383;
  struct MonoType * D.31384;
  short unsigned int D.31385;
  int D.31386;
  int D.31387;
  int D.22615;
  int iftmp.177;
  int D.22611;
  const char[8] * D.31393;
  unsigned char D.31394;
  int D.31395;
  unsigned char D.31396;
  int D.31397;
  const unsigned char * D.31402;
  unsigned char D.31403;
  int D.31404;
  const unsigned char * D.31405;
  unsigned char D.31406;
  int D.31407;
  const unsigned char * D.31412;
  unsigned char D.31413;
  int D.31414;
  const unsigned char * D.31415;
  unsigned char D.31416;
  int D.31417;
  const unsigned char * D.31422;
  unsigned char D.31423;
  int D.31424;
  const unsigned char * D.31425;
  unsigned char D.31426;
  int D.31427;
  const char * D.31429;
  int D.31432;
  int D.22624;
  int iftmp.178;
  int D.22623;
  const char[9] * D.31438;
  unsigned char D.31439;
  int D.31440;
  unsigned char D.31441;
  int D.31442;
  const unsigned char * D.31447;
  unsigned char D.31448;
  int D.31449;
  const unsigned char * D.31450;
  unsigned char D.31451;
  int D.31452;
  const unsigned char * D.31457;
  unsigned char D.31458;
  int D.31459;
  const unsigned char * D.31460;
  unsigned char D.31461;
  int D.31462;
  const unsigned char * D.31467;
  unsigned char D.31468;
  int D.31469;
  const unsigned char * D.31470;
  unsigned char D.31471;
  int D.31472;
  const char * D.31474;
  struct MonoArray * D.31477;
  long unsigned int D.31478;
  const char * D.31479;
  struct MonoString * D.31480;
  const char * p.179;
  const char * p.180;
  unsigned int D.31483;
  struct MonoType * D.31484;
  unsigned char D.31485;
  int D.31486;
  struct MonoArray * D.31487;
  char D.31488;
  short unsigned int D.31489;
  short int D.31490;
  unsigned int D.31491;
  int D.31492;
  long unsigned int D.31493;
  long int D.31494;
  struct MonoType * D.31495;
  unsigned char D.31496;
  int D.31497;
  struct MonoDomain * domain;
  struct MonoClass * enumc;
  guint j;
  guint nvalues;
  guint crow;
  void * iter;
  struct MonoClassField * field;

  try
    {
      D.31366 = MEM[(struct MonoObject *)type].vtable;
      domain = D.31366->domain;
      D.31367 = type->type;
      enumc = mono_class_from_mono_type (D.31367);
      j = 0;
      mono_class_init_or_throw (enumc);
      D.31368 = &info->utype;
      D.31369 = mono_class_enum_basetype (enumc);
      D.31370 = mono_type_get_object (domain, D.31369);
      mono_gc_wbarrier_generic_store (D.31368, D.31370);
      D.31372 = mono_class_num_fields (enumc);
      if (D.31372 != 0) goto <D.31373>; else goto <D.31374>;
      <D.31373>:
      D.31375 = mono_class_num_fields (enumc);
      D.31376 = D.31375 + -1;
      iftmp.176 = (guint) D.31376;
      goto <D.31377>;
      <D.31374>:
      iftmp.176 = 0;
      <D.31377>:
      nvalues = iftmp.176;
      D.31378 = &info->names;
      D.31379 = mono_defaults.string_class;
      D.31380 = (long unsigned int) nvalues;
      D.31381 = mono_array_new (domain, D.31379, D.31380);
      mono_gc_wbarrier_generic_store (D.31378, D.31381);
      D.31382 = &info->values;
      D.31380 = (long unsigned int) nvalues;
      D.31383 = mono_array_new (domain, enumc, D.31380);
      mono_gc_wbarrier_generic_store (D.31382, D.31383);
      crow = 4294967295;
      iter = 0B;
      goto <D.22606>;
      <D.22642>:
      {
        const char * p;
        int len;
        MonoTypeEnum def_type;

        try
          {
            D.31384 = field->type;
            D.31385 = D.31384->attrs;
            D.31386 = (int) D.31385;
            D.31387 = D.31386 & 16;
            if (D.31387 == 0) goto <D.31388>; else goto <D.31389>;
            <D.31388>:
            // predicted unlikely by continue predictor.
            goto <D.22606>;
            <D.31389>:
            {
              size_t __s1_len;
              size_t __s2_len;

              __s1_len = 7;
              if (__s1_len <= 3) goto <D.31391>; else goto <D.31392>;
              <D.31391>:
              {
                const unsigned char * __s2;
                int __result;

                __s2 = mono_field_get_name (field);
                D.31393 = "value__";
                D.31394 = MEM[(const unsigned char *)D.31393];
                D.31395 = (int) D.31394;
                D.31396 = *__s2;
                D.31397 = (int) D.31396;
                __result = D.31395 - D.31397;
                {
                  if (__s1_len != 0) goto <D.31398>; else goto <D.31399>;
                  <D.31398>:
                  if (__result == 0) goto <D.31400>; else goto <D.31401>;
                  <D.31400>:
                  D.31402 = &MEM[(void *)"value__" + 1B];
                  D.31403 = *D.31402;
                  D.31404 = (int) D.31403;
                  D.31405 = __s2 + 1;
                  D.31406 = *D.31405;
                  D.31407 = (int) D.31406;
                  __result = D.31404 - D.31407;
                  if (__s1_len > 1) goto <D.31408>; else goto <D.31409>;
                  <D.31408>:
                  if (__result == 0) goto <D.31410>; else goto <D.31411>;
                  <D.31410>:
                  D.31412 = &MEM[(void *)"value__" + 2B];
                  D.31413 = *D.31412;
                  D.31414 = (int) D.31413;
                  D.31415 = __s2 + 2;
                  D.31416 = *D.31415;
                  D.31417 = (int) D.31416;
                  __result = D.31414 - D.31417;
                  if (__s1_len > 2) goto <D.31418>; else goto <D.31419>;
                  <D.31418>:
                  if (__result == 0) goto <D.31420>; else goto <D.31421>;
                  <D.31420>:
                  D.31422 = &MEM[(void *)"value__" + 3B];
                  D.31423 = *D.31422;
                  D.31424 = (int) D.31423;
                  D.31425 = __s2 + 3;
                  D.31426 = *D.31425;
                  D.31427 = (int) D.31426;
                  __result = D.31424 - D.31427;
                  <D.31421>:
                  <D.31419>:
                  <D.31411>:
                  <D.31409>:
                  <D.31401>:
                  <D.31399>:
                }
                D.22611 = __result;
              }
              iftmp.177 = D.22611;
              goto <D.31428>;
              <D.31392>:
              D.31429 = mono_field_get_name (field);
              iftmp.177 = __builtin_strcmp ("value__", D.31429);
              <D.31428>:
              D.22615 = iftmp.177;
            }
            if (D.22615 == 0) goto <D.31430>; else goto <D.31431>;
            <D.31430>:
            // predicted unlikely by continue predictor.
            goto <D.22606>;
            <D.31431>:
            D.31384 = field->type;
            D.31385 = D.31384->attrs;
            D.31386 = (int) D.31385;
            D.31432 = D.31386 & 1536;
            if (D.31432 != 0) goto <D.31433>; else goto <D.31434>;
            <D.31433>:
            {
              size_t __s1_len;
              size_t __s2_len;

              __s2_len = 8;
              if (__s2_len <= 3) goto <D.31436>; else goto <D.31437>;
              <D.31436>:
              {
                const unsigned char * __s2;
                int __result;

                __s2 = mono_field_get_name (field);
                D.31438 = "_Deleted";
                D.31439 = MEM[(const unsigned char *)D.31438];
                D.31440 = (int) D.31439;
                D.31441 = *__s2;
                D.31442 = (int) D.31441;
                __result = D.31440 - D.31442;
                {
                  if (__s2_len != 0) goto <D.31443>; else goto <D.31444>;
                  <D.31443>:
                  if (__result == 0) goto <D.31445>; else goto <D.31446>;
                  <D.31445>:
                  D.31447 = &MEM[(void *)"_Deleted" + 1B];
                  D.31448 = *D.31447;
                  D.31449 = (int) D.31448;
                  D.31450 = __s2 + 1;
                  D.31451 = *D.31450;
                  D.31452 = (int) D.31451;
                  __result = D.31449 - D.31452;
                  if (__s2_len > 1) goto <D.31453>; else goto <D.31454>;
                  <D.31453>:
                  if (__result == 0) goto <D.31455>; else goto <D.31456>;
                  <D.31455>:
                  D.31457 = &MEM[(void *)"_Deleted" + 2B];
                  D.31458 = *D.31457;
                  D.31459 = (int) D.31458;
                  D.31460 = __s2 + 2;
                  D.31461 = *D.31460;
                  D.31462 = (int) D.31461;
                  __result = D.31459 - D.31462;
                  if (__s2_len > 2) goto <D.31463>; else goto <D.31464>;
                  <D.31463>:
                  if (__result == 0) goto <D.31465>; else goto <D.31466>;
                  <D.31465>:
                  D.31467 = &MEM[(void *)"_Deleted" + 3B];
                  D.31468 = *D.31467;
                  D.31469 = (int) D.31468;
                  D.31470 = __s2 + 3;
                  D.31471 = *D.31470;
                  D.31472 = (int) D.31471;
                  __result = D.31469 - D.31472;
                  <D.31466>:
                  <D.31464>:
                  <D.31456>:
                  <D.31454>:
                  <D.31446>:
                  <D.31444>:
                }
                D.22623 = __result;
              }
              iftmp.178 = -D.22623;
              goto <D.31473>;
              <D.31437>:
              D.31474 = mono_field_get_name (field);
              iftmp.178 = __builtin_strcmp (D.31474, "_Deleted");
              <D.31473>:
              D.22624 = iftmp.178;
            }
            if (D.22624 == 0) goto <D.31475>; else goto <D.31476>;
            <D.31475>:
            // predicted unlikely by continue predictor.
            goto <D.22606>;
            <D.31476>:
            <D.31434>:
            {
              void * * __p;

              D.31477 = info->names;
              D.31478 = (long unsigned int) j;
              __p = mono_array_addr_with_size (D.31477, 8, D.31478);
              D.31477 = info->names;
              D.31479 = mono_field_get_name (field);
              D.31480 = mono_string_new (domain, D.31479);
              mono_gc_wbarrier_set_arrayref (D.31477, __p, D.31480);
            }
            p.179 = mono_class_get_field_default_value (field, &def_type);
            p = p.179;
            p.180 = p;
            D.31483 = mono_metadata_decode_blob_size (p.180, &p);
            len = (int) D.31483;
            D.31484 = mono_class_enum_basetype (enumc);
            D.31485 = D.31484->type;
            D.31486 = (int) D.31485;
            switch (D.31486) <default: <D.22640>, case 3: <D.22630>, case 4: <D.22627>, case 5: <D.22626>, case 6: <D.22632>, case 7: <D.22631>, case 8: <D.22635>, case 9: <D.22634>, case 10: <D.22638>, case 11: <D.22637>>
            <D.22626>:
            <D.22627>:
            {
              gchar * __p;

              D.31487 = info->values;
              D.31478 = (long unsigned int) j;
              __p = mono_array_addr_with_size (D.31487, 1, D.31478);
              p.180 = p;
              D.31488 = *p.180;
              *__p = D.31488;
            }
            goto <D.22629>;
            <D.22630>:
            <D.22631>:
            <D.22632>:
            {
              gint16 * __p;

              D.31487 = info->values;
              D.31478 = (long unsigned int) j;
              __p = mono_array_addr_with_size (D.31487, 2, D.31478);
              p.180 = p;
              D.31489 = MEM[(const guint16 *)p.180];
              D.31490 = (short int) D.31489;
              *__p = D.31490;
            }
            goto <D.22629>;
            <D.22634>:
            <D.22635>:
            {
              gint32 * __p;

              D.31487 = info->values;
              D.31478 = (long unsigned int) j;
              __p = mono_array_addr_with_size (D.31487, 4, D.31478);
              p.180 = p;
              D.31491 = MEM[(const guint32 *)p.180];
              D.31492 = (int) D.31491;
              *__p = D.31492;
            }
            goto <D.22629>;
            <D.22637>:
            <D.22638>:
            {
              gint64 * __p;

              D.31487 = info->values;
              D.31478 = (long unsigned int) j;
              __p = mono_array_addr_with_size (D.31487, 8, D.31478);
              p.180 = p;
              D.31493 = MEM[(const guint64 *)p.180];
              D.31494 = (long int) D.31493;
              *__p = D.31494;
            }
            goto <D.22629>;
            <D.22640>:
            D.31495 = mono_class_enum_basetype (enumc);
            D.31496 = D.31495->type;
            D.31497 = (int) D.31496;
            monoeg_g_log (0B, 4, "Implement type 0x%02x in get_enum_info", D.31497);
            <D.22641>:
            goto <D.22641>;
            <D.22629>:
            j = j + 1;
          }
        finally
          {
            p = {CLOBBER};
            def_type = {CLOBBER};
          }
      }
      <D.22606>:
      field = mono_class_get_fields (enumc, &iter);
      if (field != 0B) goto <D.22642>; else goto <D.22643>;
      <D.22643>:
    }
  finally
    {
      iter = {CLOBBER};
    }
}


custom_attrs_defined_internal (struct MonoObject * obj, struct MonoReflectionType * attr_type)
{
  struct MonoType * D.31500;
  MonoBoolean D.31503;
  int D.31504;
  struct MonoClass * attr_class;
  struct MonoCustomAttrInfo * cinfo;
  gboolean found;

  D.31500 = attr_type->type;
  attr_class = mono_class_from_mono_type (D.31500);
  mono_class_init_or_throw (attr_class);
  cinfo = mono_reflection_get_custom_attrs_info (obj);
  if (cinfo == 0B) goto <D.31501>; else goto <D.31502>;
  <D.31501>:
  D.31503 = 0;
  return D.31503;
  <D.31502>:
  found = mono_custom_attrs_has_attr (cinfo, attr_class);
  D.31504 = cinfo->cached;
  if (D.31504 == 0) goto <D.31505>; else goto <D.31506>;
  <D.31505>:
  mono_custom_attrs_free (cinfo);
  <D.31506>:
  D.31503 = (MonoBoolean) found;
  return D.31503;
}


custom_attrs_get_by_type (struct MonoObject * obj, struct MonoReflectionType * attr_type)
{
  struct MonoClass * iftmp.181;
  struct MonoType * D.31511;
  int D.31515;
  struct MonoLoaderError * D.31518;
  struct MonoLoaderError * D.31521;
  struct MonoException * D.31522;
  struct MonoArray * D.31523;
  struct MonoClass * attr_class;
  struct MonoArray * res;
  struct MonoError error;

  try
    {
      if (attr_type != 0B) goto <D.31509>; else goto <D.31510>;
      <D.31509>:
      D.31511 = attr_type->type;
      iftmp.181 = mono_class_from_mono_type (D.31511);
      goto <D.31512>;
      <D.31510>:
      iftmp.181 = 0B;
      <D.31512>:
      attr_class = iftmp.181;
      if (attr_class != 0B) goto <D.31513>; else goto <D.31514>;
      <D.31513>:
      mono_class_init_or_throw (attr_class);
      <D.31514>:
      res = mono_reflection_get_custom_attrs_by_type (obj, attr_class, &error);
      D.31515 = mono_error_ok (&error);
      if (D.31515 == 0) goto <D.31516>; else goto <D.31517>;
      <D.31516>:
      mono_error_raise_exception (&error);
      <D.31517>:
      D.31518 = mono_loader_get_last_error ();
      if (D.31518 != 0B) goto <D.31519>; else goto <D.31520>;
      <D.31519>:
      D.31521 = mono_loader_get_last_error ();
      D.31522 = mono_loader_error_prepare_exception (D.31521);
      mono_raise_exception (D.31522);
      monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "icall.c", 7569);
      D.31523 = 0B;
      return D.31523;
      <D.31520>:
      D.31523 = res;
      return D.31523;
    }
  finally
    {
      error = {CLOBBER};
    }
}


ves_icall_System_IO_get_temp_path ()
{
  struct MonoString * D.31526;
  struct MonoDomain * D.31527;
  const gchar * D.31528;

  D.31527 = mono_domain_get ();
  D.31528 = monoeg_g_get_tmp_dir ();
  D.31526 = mono_string_new (D.31527, D.31528);
  return D.31526;
}


ves_icall_System_IO_DriveInfo_GetDriveType (struct MonoString * root_path_name)
{
  guint32 D.31530;
  mono_unichar2 * D.31531;

  D.31531 = mono_string_chars (root_path_name);
  D.31530 = GetDriveType (D.31531);
  return D.31530;
}


ves_icall_System_IO_DriveInfo_GetDriveFormat (struct MonoString * path)
{
  mono_unichar2 * D.31533;
  int D.31534;
  struct MonoString * D.31537;
  gunichar2 volume_name[261];

  try
    {
      D.31533 = mono_string_chars (path);
      D.31534 = GetVolumeInformation (D.31533, 0B, 0, 0B, 0B, 0B, &volume_name, 261);
      if (D.31534 == 0) goto <D.31535>; else goto <D.31536>;
      <D.31535>:
      D.31537 = 0B;
      return D.31537;
      <D.31536>:
      D.31537 = mono_string_from_utf16 (&volume_name);
      return D.31537;
    }
  finally
    {
      volume_name = {CLOBBER};
    }
}


ves_icall_System_IO_DriveInfo_GetDiskFreeSpace (struct MonoString * path_name, guint64 * free_bytes_avail, guint64 * total_number_of_bytes, guint64 * total_number_of_free_bytes, gint32 * error)
{
  mono_unichar2 * D.31540;
  long unsigned int D.31543;
  long unsigned int D.31544;
  long unsigned int D.31545;
  unsigned int D.31547;
  int D.31548;
  MonoBoolean D.31549;
  gboolean result;
  union ULARGE_INTEGER wapi_free_bytes_avail;
  union ULARGE_INTEGER wapi_total_number_of_bytes;
  union ULARGE_INTEGER wapi_total_number_of_free_bytes;

  try
    {
      *error = 0;
      D.31540 = mono_string_chars (path_name);
      result = GetDiskFreeSpaceEx (D.31540, &wapi_free_bytes_avail, &wapi_total_number_of_bytes, &wapi_total_number_of_free_bytes);
      if (result != 0) goto <D.31541>; else goto <D.31542>;
      <D.31541>:
      D.31543 = wapi_free_bytes_avail.QuadPart;
      *free_bytes_avail = D.31543;
      D.31544 = wapi_total_number_of_bytes.QuadPart;
      *total_number_of_bytes = D.31544;
      D.31545 = wapi_total_number_of_free_bytes.QuadPart;
      *total_number_of_free_bytes = D.31545;
      goto <D.31546>;
      <D.31542>:
      *free_bytes_avail = 0;
      *total_number_of_bytes = 0;
      *total_number_of_free_bytes = 0;
      D.31547 = GetLastError ();
      D.31548 = (int) D.31547;
      *error = D.31548;
      <D.31546>:
      D.31549 = (MonoBoolean) result;
      return D.31549;
    }
  finally
    {
      wapi_free_bytes_avail = {CLOBBER};
      wapi_total_number_of_bytes = {CLOBBER};
      wapi_total_number_of_free_bytes = {CLOBBER};
    }
}


ves_icall_System_Environment_InternalGetHome ()
{
  struct MonoString * D.31552;
  struct MonoDomain * D.31553;
  const gchar * D.31554;

  D.31553 = mono_domain_get ();
  D.31554 = monoeg_g_get_home_dir ();
  D.31552 = mono_string_new (D.31553, D.31554);
  return D.31552;
}


ves_icall_System_Environment_GetGacPath ()
{
  struct MonoString * D.31556;
  struct MonoDomain * D.31557;
  const char * D.31558;

  D.31557 = mono_domain_get ();
  D.31558 = mono_assembly_getrootdir ();
  D.31556 = mono_string_new (D.31557, D.31558);
  return D.31556;
}


ves_icall_System_Environment_GetEnvironmentVariable (struct MonoString * name)
{
  struct MonoString * D.31562;
  struct MonoDomain * D.31565;
  const gchar * value;
  gchar * utf8_name;

  if (name == 0B) goto <D.31560>; else goto <D.31561>;
  <D.31560>:
  D.31562 = 0B;
  return D.31562;
  <D.31561>:
  utf8_name = mono_string_to_utf8 (name);
  value = monoeg_g_getenv (utf8_name);
  monoeg_g_free (utf8_name);
  if (value == 0B) goto <D.31563>; else goto <D.31564>;
  <D.31563>:
  D.31562 = 0B;
  return D.31562;
  <D.31564>:
  D.31565 = mono_domain_get ();
  D.31562 = mono_string_new (D.31565, value);
  return D.31562;
}


ves_icall_System_Environment_BroadcastSettingChange ()
{

}


ves_icall_System_Environment_get_Platform ()
{
  int D.31567;

  D.31567 = 4;
  return D.31567;
}


ves_icall_System_Environment_get_MachineName ()
{
  int D.31569;
  struct MonoDomain * D.31572;
  struct MonoString * D.31574;
  gchar buf[256];
  struct MonoString * result;

  try
    {
      D.31569 = gethostname (&buf, 256);
      if (D.31569 == 0) goto <D.31570>; else goto <D.31571>;
      <D.31570>:
      D.31572 = mono_domain_get ();
      result = mono_string_new (D.31572, &buf);
      goto <D.31573>;
      <D.31571>:
      result = 0B;
      <D.31573>:
      D.31574 = result;
      return D.31574;
    }
  finally
    {
      buf = {CLOBBER};
    }
}


gethostname (char * __buf, size_t __buflen)
{
  long unsigned int D.31577;
  int D.31580;
  int D.31583;
  long unsigned int D.31584;
  long unsigned int D.31585;
  long unsigned int D.31588;

  D.31577 = __builtin_object_size (__buf, 1);
  if (D.31577 != 18446744073709551615) goto <D.31578>; else goto <D.31579>;
  <D.31578>:
  D.31580 = __builtin_constant_p (__buflen);
  if (D.31580 == 0) goto <D.31581>; else goto <D.31582>;
  <D.31581>:
  D.31584 = __builtin_object_size (__buf, 1);
  D.31583 = __gethostname_chk (__buf, __buflen, D.31584);
  return D.31583;
  <D.31582>:
  D.31585 = __builtin_object_size (__buf, 1);
  if (D.31585 < __buflen) goto <D.31586>; else goto <D.31587>;
  <D.31586>:
  D.31588 = __builtin_object_size (__buf, 1);
  D.31583 = __gethostname_chk_warn (__buf, __buflen, D.31588);
  return D.31583;
  <D.31587>:
  <D.31579>:
  D.31583 = __gethostname_alias (__buf, __buflen);
  return D.31583;
}


ves_icall_System_Environment_get_HasShutdownStarted ()
{
  int D.31590;
  MonoBoolean D.31593;
  struct MonoDomain * D.31594;
  int D.31595;

  D.31590 = mono_runtime_is_shutting_down ();
  if (D.31590 != 0) goto <D.31591>; else goto <D.31592>;
  <D.31591>:
  D.31593 = 1;
  return D.31593;
  <D.31592>:
  D.31594 = mono_domain_get ();
  D.31595 = mono_domain_is_unloading (D.31594);
  if (D.31595 != 0) goto <D.31596>; else goto <D.31597>;
  <D.31596>:
  D.31593 = 1;
  return D.31593;
  <D.31597>:
  D.31593 = 0;
  return D.31593;
}


ves_icall_System_Environment_InternalSetEnvironmentVariable (struct MonoString * name, struct MonoString * value)
{
  int D.31602;
  mono_unichar2 * D.31604;
  short unsigned int D.31605;
  int D.31606;
  struct MonoError error;
  gchar * utf8_name;
  gchar * utf8_value;

  try
    {
      utf8_name = mono_string_to_utf8 (name);
      if (value == 0B) goto <D.31599>; else goto <D.31601>;
      <D.31601>:
      D.31602 = mono_string_length (value);
      if (D.31602 == 0) goto <D.31599>; else goto <D.31603>;
      <D.31603>:
      D.31604 = mono_string_chars (value);
      D.31605 = *D.31604;
      if (D.31605 == 0) goto <D.31599>; else goto <D.31600>;
      <D.31599>:
      monoeg_g_unsetenv (utf8_name);
      monoeg_g_free (utf8_name);
      return;
      <D.31600>:
      utf8_value = mono_string_to_utf8_checked (value, &error);
      D.31606 = mono_error_ok (&error);
      if (D.31606 == 0) goto <D.31607>; else goto <D.31608>;
      <D.31607>:
      monoeg_g_free (utf8_name);
      mono_error_raise_exception (&error);
      <D.31608>:
      monoeg_g_setenv (utf8_name, utf8_value, 1);
      monoeg_g_free (utf8_name);
      monoeg_g_free (utf8_value);
    }
  finally
    {
      error = {CLOBBER};
    }
}


ves_icall_System_Environment_GetWindowsFolderPath (int folder)
{
  struct MonoString * D.31612;
  struct MonoDomain * D.31613;

  monoeg_g_log (0B, 16, "ves_icall_System_Environment_GetWindowsFolderPath should only be called on Windows!");
  D.31613 = mono_domain_get ();
  D.31612 = mono_string_new (D.31613, "");
  return D.31612;
}


ves_icall_System_Environment_get_NewLine ()
{
  struct MonoString * D.31615;
  struct MonoDomain * D.31616;

  D.31616 = mono_domain_get ();
  D.31615 = mono_string_new (D.31616, "\n");
  return D.31615;
}


ves_icall_System_Environment_GetLogicalDrives ()
{
  int D.31618;
  unsigned int D.31623;
  long unsigned int D.31624;
  long unsigned int D.31625;
  gunichar2 * dname.182;
  short unsigned int D.31627;
  short unsigned int D.31628;
  struct MonoClass * D.31629;
  long unsigned int D.31630;
  short unsigned int D.31631;
  int ndrives.183;
  long unsigned int D.31633;
  gunichar2 * dname.184;
  short unsigned int D.31635;
  struct MonoArray * D.31638;
  gunichar2 buf[256];
  gunichar2 * ptr;
  gunichar2 * dname;
  gunichar2 * u16;
  guint initial_size;
  guint size;
  gint ndrives;
  struct MonoArray * result;
  struct MonoString * drivestr;
  struct MonoDomain * domain;
  gint len;

  try
    {
      initial_size = 127;
      size = 128;
      domain = mono_domain_get ();
      buf[0] = 0;
      ptr = &buf;
      goto <D.23798>;
      <D.23797>:
      D.31618 = GetLogicalDriveStrings (initial_size, ptr);
      size = (guint) D.31618;
      if (size > initial_size) goto <D.31619>; else goto <D.31620>;
      <D.31619>:
      if (&buf != ptr) goto <D.31621>; else goto <D.31622>;
      <D.31621>:
      monoeg_g_free (ptr);
      <D.31622>:
      D.31623 = size + 1;
      D.31624 = (long unsigned int) D.31623;
      D.31625 = D.31624 * 2;
      ptr = monoeg_malloc0 (D.31625);
      initial_size = size;
      size = size + 1;
      <D.31620>:
      <D.23798>:
      if (size > initial_size) goto <D.23797>; else goto <D.23799>;
      <D.23799>:
      dname = ptr;
      ndrives = 0;
      <D.23803>:
      goto <D.23801>;
      <D.23800>:
      <D.23801>:
      dname.182 = dname;
      dname = dname.182 + 2;
      D.31627 = *dname.182;
      if (D.31627 != 0) goto <D.23800>; else goto <D.23802>;
      <D.23802>:
      ndrives = ndrives + 1;
      D.31628 = *dname;
      if (D.31628 != 0) goto <D.23803>; else goto <D.23804>;
      <D.23804>:
      dname = ptr;
      D.31629 = mono_defaults.string_class;
      D.31630 = (long unsigned int) ndrives;
      result = mono_array_new (domain, D.31629, D.31630);
      ndrives = 0;
      <D.23812>:
      len = 0;
      u16 = dname;
      goto <D.23806>;
      <D.23805>:
      u16 = u16 + 2;
      len = len + 1;
      <D.23806>:
      D.31631 = *u16;
      if (D.31631 != 0) goto <D.23805>; else goto <D.23807>;
      <D.23807>:
      drivestr = mono_string_new_utf16 (domain, dname, len);
      {
        void * * __p;

        ndrives.183 = ndrives;
        ndrives = ndrives.183 + 1;
        D.31633 = (long unsigned int) ndrives.183;
        __p = mono_array_addr_with_size (result, 8, D.31633);
        mono_gc_wbarrier_set_arrayref (result, __p, drivestr);
      }
      goto <D.23810>;
      <D.23809>:
      <D.23810>:
      dname.184 = dname;
      dname = dname.184 + 2;
      D.31635 = *dname.184;
      if (D.31635 != 0) goto <D.23809>; else goto <D.23811>;
      <D.23811>:
      D.31628 = *dname;
      if (D.31628 != 0) goto <D.23812>; else goto <D.23813>;
      <D.23813>:
      if (&buf != ptr) goto <D.31636>; else goto <D.31637>;
      <D.31636>:
      monoeg_g_free (ptr);
      <D.31637>:
      D.31638 = result;
      return D.31638;
    }
  finally
    {
      buf = {CLOBBER};
    }
}


ves_icall_System_Environment_GetEnvironmentVariableNames ()
{
  gchar * D.31641;
  struct MonoClass * D.31642;
  long unsigned int D.31643;
  gchar * D.31644;
  struct MonoArray * D.31647;
  struct MonoArray * names;
  struct MonoDomain * domain;
  struct MonoString * str;
  gchar * * e;
  gchar * * parts;
  int n;

  n = 0;
  e = environ;
  goto <D.23761>;
  <D.23760>:
  n = n + 1;
  e = e + 8;
  <D.23761>:
  D.31641 = *e;
  if (D.31641 != 0B) goto <D.23760>; else goto <D.23762>;
  <D.23762>:
  domain = mono_domain_get ();
  D.31642 = mono_defaults.string_class;
  D.31643 = (long unsigned int) n;
  names = mono_array_new (domain, D.31642, D.31643);
  n = 0;
  e = environ;
  goto <D.23765>;
  <D.23764>:
  D.31641 = *e;
  parts = monoeg_g_strsplit (D.31641, "=", 2);
  D.31644 = *parts;
  if (D.31644 != 0B) goto <D.31645>; else goto <D.31646>;
  <D.31645>:
  D.31644 = *parts;
  str = mono_string_new (domain, D.31644);
  {
    void * * __p;

    D.31643 = (long unsigned int) n;
    __p = mono_array_addr_with_size (names, 8, D.31643);
    mono_gc_wbarrier_set_arrayref (names, __p, str);
  }
  <D.31646>:
  monoeg_g_strfreev (parts);
  n = n + 1;
  e = e + 8;
  <D.23765>:
  D.31641 = *e;
  if (D.31641 != 0B) goto <D.23764>; else goto <D.23766>;
  <D.23766>:
  D.31647 = names;
  return D.31647;
}


ves_icall_System_Environment_Exit (int result)
{
  int D.31649;

  mono_environment_exitcode_set (result);
  D.31649 = mono_runtime_try_shutdown ();
  if (D.31649 == 0) goto <D.31650>; else goto <D.31651>;
  <D.31650>:
  mono_thread_exit ();
  <D.31651>:
  mono_thread_suspend_all_other_threads ();
  mono_runtime_quit ();
  exit (result);
}


ves_icall_System_Enum_get_value (struct MonoObject * this)
{
  struct MonoObject * D.31654;
  struct MonoVTable * D.31655;
  struct MonoClass * D.31656;
  long unsigned int D.31657;
  long unsigned int D.31658;
  _Bool D.31659;
  long int D.31660;
  long int D.31661;
  struct MonoType * D.31664;
  struct MonoDomain * D.31665;
  long unsigned int D.31666;
  struct MonoObject * res;
  struct MonoClass * enumc;
  void * dst;
  void * src;
  int size;

  if (this == 0B) goto <D.31652>; else goto <D.31653>;
  <D.31652>:
  D.31654 = 0B;
  return D.31654;
  <D.31653>:
  D.31655 = this->vtable;
  D.31656 = D.31655->klass;
  D.31657 = BIT_FIELD_REF <*D.31656, 64, 256>;
  D.31658 = D.31657 & 16;
  D.31659 = D.31658 == 0;
  D.31660 = (long int) D.31659;
  D.31661 = __builtin_expect (D.31660, 0);
  if (D.31661 != 0) goto <D.31662>; else goto <D.31663>;
  <D.31662>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "icall.c", 3088, "this->vtable->klass->enumtype");
  <D.31663>:
  D.31655 = this->vtable;
  D.31656 = D.31655->klass;
  D.31664 = mono_class_enum_basetype (D.31656);
  enumc = mono_class_from_mono_type (D.31664);
  D.31655 = this->vtable;
  D.31665 = D.31655->domain;
  res = mono_object_new (D.31665, enumc);
  dst = res + 16;
  src = this + 16;
  size = mono_class_value_size (enumc, 0B);
  D.31666 = (long unsigned int) size;
  memcpy (dst, src, D.31666);
  D.31654 = res;
  return D.31654;
}


ves_icall_System_Enum_get_underlying_type (struct MonoReflectionType * type)
{
  struct MonoType * D.31668;
  struct MonoException * D.31671;
  struct MonoReflectionType * D.31672;
  struct MonoVTable * D.31673;
  struct MonoDomain * D.31674;
  struct MonoType * etype;
  struct MonoClass * klass;

  D.31668 = type->type;
  klass = mono_class_from_mono_type (D.31668);
  mono_class_init_or_throw (klass);
  etype = mono_class_enum_basetype (klass);
  if (etype == 0B) goto <D.31669>; else goto <D.31670>;
  <D.31669>:
  D.31671 = mono_get_exception_argument ("Type must be a type provided by the runtime.", "enumType");
  mono_raise_exception (D.31671);
  <D.31670>:
  D.31673 = MEM[(struct MonoObject *)type].vtable;
  D.31674 = D.31673->domain;
  D.31672 = mono_type_get_object (D.31674, etype);
  return D.31672;
}


ves_icall_System_Enum_get_hashcode (struct MonoObject * this)
{
  struct MonoVTable * D.31676;
  struct MonoClass * D.31677;
  _Bool D.31678;
  long int D.31679;
  long int D.31680;
  unsigned char D.31683;
  int D.31684;
  int D.31685;
  signed char D.31686;
  unsigned char D.31687;
  short unsigned int D.31688;
  short int D.31689;
  unsigned int D.31690;
  int D.31691;
  long int D.31692;
  int D.31693;
  void * data;
  struct MonoType * basetype;

  data = this + 16;
  D.31676 = this->vtable;
  D.31677 = D.31676->klass;
  basetype = mono_class_enum_basetype (D.31677);
  D.31678 = basetype == 0B;
  D.31679 = (long int) D.31678;
  D.31680 = __builtin_expect (D.31679, 0);
  if (D.31680 != 0) goto <D.31681>; else goto <D.31682>;
  <D.31681>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "icall.c", 3175, "basetype");
  <D.31682>:
  D.31683 = basetype->type;
  D.31684 = (int) D.31683;
  switch (D.31684) <default: <D.22590>, case 3: <D.22582>, case 4: <D.22580>, case 5: <D.22581>, case 6: <D.22584>, case 7: <D.22583>, case 8: <D.22586>, case 9: <D.22585>, case 10: <D.22588>, case 11: <D.22587>>
  <D.22580>:
  D.31686 = MEM[(gint8 *)data];
  D.31685 = (int) D.31686;
  return D.31685;
  <D.22581>:
  D.31687 = MEM[(guint8 *)data];
  D.31685 = (int) D.31687;
  return D.31685;
  <D.22582>:
  <D.22583>:
  D.31688 = MEM[(guint16 *)data];
  D.31685 = (int) D.31688;
  return D.31685;
  <D.22584>:
  D.31689 = MEM[(gint16 *)data];
  D.31685 = (int) D.31689;
  return D.31685;
  <D.22585>:
  D.31690 = MEM[(guint32 *)data];
  D.31685 = (int) D.31690;
  return D.31685;
  <D.22586>:
  D.31685 = MEM[(gint32 *)data];
  return D.31685;
  <D.22587>:
  <D.22588>:
  {
    gint64 value;

    value = MEM[(gint64 *)data];
    D.31691 = (int) value;
    D.31692 = value >> 32;
    D.31693 = (int) D.31692;
    D.31685 = D.31691 ^ D.31693;
    return D.31685;
  }
  <D.22590>:
  D.31683 = basetype->type;
  D.31684 = (int) D.31683;
  monoeg_g_log (0B, 4, "Implement type 0x%02x in get_hashcode", D.31684);
  <D.22591>:
  goto <D.22591>;
  D.31685 = 0;
  return D.31685;
}


ves_icall_System_Enum_compare_value_to (struct MonoObject * this, struct MonoObject * other)
{
  struct MonoVTable * D.31695;
  struct MonoClass * D.31696;
  _Bool D.31697;
  long int D.31698;
  long int D.31699;
  unsigned char D.31702;
  int D.31703;
  int D.31706;
  int iftmp.185;
  int iftmp.186;
  int D.31719;
  int D.31720;
  int iftmp.187;
  int iftmp.188;
  int iftmp.189;
  int iftmp.190;
  int iftmp.191;
  void * tdata;
  void * odata;
  struct MonoType * basetype;

  tdata = this + 16;
  odata = other + 16;
  D.31695 = this->vtable;
  D.31696 = D.31695->klass;
  basetype = mono_class_enum_basetype (D.31696);
  D.31697 = basetype == 0B;
  D.31698 = (long int) D.31697;
  D.31699 = __builtin_expect (D.31698, 0);
  if (D.31699 != 0) goto <D.31700>; else goto <D.31701>;
  <D.31700>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "icall.c", 3126, "basetype");
  <D.31701>:
  D.31702 = basetype->type;
  D.31703 = (int) D.31702;
  switch (D.31703) <default: <D.22573>, case 3: <D.22554>, case 4: <D.22551>, case 5: <D.22548>, case 6: <D.22558>, case 7: <D.22555>, case 8: <D.22564>, case 9: <D.22561>, case 10: <D.22570>, case 11: <D.22567>>
  <D.22548>:
  {
    guint8 me;
    guint8 other;

    me = MEM[(guint8 *)tdata];
    other = MEM[(guint8 *)odata];
    if (me == other) goto <D.31704>; else goto <D.31705>;
    <D.31704>:
    D.31706 = 0;
    return D.31706;
    <D.31705>:
    if (me > other) goto <D.31708>; else goto <D.31709>;
    <D.31708>:
    iftmp.185 = 1;
    goto <D.31710>;
    <D.31709>:
    iftmp.185 = -1;
    <D.31710>:
    D.31706 = iftmp.185;
    return D.31706;
  }
  <D.22551>:
  {
    gint8 me;
    gint8 other;

    me = MEM[(gint8 *)tdata];
    other = MEM[(gint8 *)odata];
    if (me == other) goto <D.31711>; else goto <D.31712>;
    <D.31711>:
    D.31706 = 0;
    return D.31706;
    <D.31712>:
    if (me > other) goto <D.31714>; else goto <D.31715>;
    <D.31714>:
    iftmp.186 = 1;
    goto <D.31716>;
    <D.31715>:
    iftmp.186 = -1;
    <D.31716>:
    D.31706 = iftmp.186;
    return D.31706;
  }
  <D.22554>:
  <D.22555>:
  {
    guint16 me;
    guint16 other;

    me = MEM[(guint16 *)tdata];
    other = MEM[(guint16 *)odata];
    if (me == other) goto <D.31717>; else goto <D.31718>;
    <D.31717>:
    D.31706 = 0;
    return D.31706;
    <D.31718>:
    D.31719 = (int) me;
    D.31720 = (int) other;
    D.31706 = D.31719 - D.31720;
    return D.31706;
  }
  <D.22558>:
  {
    gint16 me;
    gint16 other;

    me = MEM[(gint16 *)tdata];
    other = MEM[(gint16 *)odata];
    if (me == other) goto <D.31721>; else goto <D.31722>;
    <D.31721>:
    D.31706 = 0;
    return D.31706;
    <D.31722>:
    if (me > other) goto <D.31724>; else goto <D.31725>;
    <D.31724>:
    iftmp.187 = 1;
    goto <D.31726>;
    <D.31725>:
    iftmp.187 = -1;
    <D.31726>:
    D.31706 = iftmp.187;
    return D.31706;
  }
  <D.22561>:
  {
    guint32 me;
    guint32 other;

    me = MEM[(guint32 *)tdata];
    other = MEM[(guint32 *)odata];
    if (me == other) goto <D.31727>; else goto <D.31728>;
    <D.31727>:
    D.31706 = 0;
    return D.31706;
    <D.31728>:
    if (me > other) goto <D.31730>; else goto <D.31731>;
    <D.31730>:
    iftmp.188 = 1;
    goto <D.31732>;
    <D.31731>:
    iftmp.188 = -1;
    <D.31732>:
    D.31706 = iftmp.188;
    return D.31706;
  }
  <D.22564>:
  {
    gint32 me;
    gint32 other;

    me = MEM[(gint32 *)tdata];
    other = MEM[(gint32 *)odata];
    if (me == other) goto <D.31733>; else goto <D.31734>;
    <D.31733>:
    D.31706 = 0;
    return D.31706;
    <D.31734>:
    if (me > other) goto <D.31736>; else goto <D.31737>;
    <D.31736>:
    iftmp.189 = 1;
    goto <D.31738>;
    <D.31737>:
    iftmp.189 = -1;
    <D.31738>:
    D.31706 = iftmp.189;
    return D.31706;
  }
  <D.22567>:
  {
    guint64 me;
    guint64 other;

    me = MEM[(guint64 *)tdata];
    other = MEM[(guint64 *)odata];
    if (me == other) goto <D.31739>; else goto <D.31740>;
    <D.31739>:
    D.31706 = 0;
    return D.31706;
    <D.31740>:
    if (me > other) goto <D.31742>; else goto <D.31743>;
    <D.31742>:
    iftmp.190 = 1;
    goto <D.31744>;
    <D.31743>:
    iftmp.190 = -1;
    <D.31744>:
    D.31706 = iftmp.190;
    return D.31706;
  }
  <D.22570>:
  {
    gint64 me;
    gint64 other;

    me = MEM[(gint64 *)tdata];
    other = MEM[(gint64 *)odata];
    if (me == other) goto <D.31745>; else goto <D.31746>;
    <D.31745>:
    D.31706 = 0;
    return D.31706;
    <D.31746>:
    if (me > other) goto <D.31748>; else goto <D.31749>;
    <D.31748>:
    iftmp.191 = 1;
    goto <D.31750>;
    <D.31749>:
    iftmp.191 = -1;
    <D.31750>:
    D.31706 = iftmp.191;
    return D.31706;
  }
  <D.22573>:
  D.31702 = basetype->type;
  D.31703 = (int) D.31702;
  monoeg_g_log (0B, 4, "Implement type 0x%02x in get_hashcode", D.31703);
  <D.22574>:
  goto <D.22574>;
  D.31706 = 0;
  return D.31706;
}


ves_icall_System_Enum_ToObject (struct MonoReflectionType * enumType, struct MonoObject * value)
{
  _Bool D.31752;
  long int D.31753;
  long int D.31754;
  _Bool D.31759;
  long int D.31760;
  long int D.31761;
  struct MonoVTable * D.31766;
  struct MonoType * D.31767;
  struct MonoVTable * D.31768;
  long unsigned int D.31769;
  long unsigned int D.31770;
  struct MonoException * D.31773;
  long unsigned int D.31774;
  long unsigned int D.31775;
  unsigned char D.31778;
  unsigned char D.31779;
  struct MonoException * D.31782;
  struct MonoException * D.31785;
  char * D.31786;
  int iftmp.192;
  struct MonoType * D.31790;
  unsigned char D.31791;
  char * D.31793;
  unsigned char D.31794;
  int D.31795;
  struct MonoObject * D.31796;
  struct MonoDomain * domain;
  struct MonoClass * enumc;
  struct MonoClass * objc;
  struct MonoObject * res;
  struct MonoType * etype;
  guint64 val;

  D.31752 = enumType == 0B;
  D.31753 = (long int) D.31752;
  D.31754 = __builtin_expect (D.31753, 0);
  if (D.31754 != 0) goto <D.31755>; else goto <D.31756>;
  <D.31755>:
  {
    struct MonoException * ex;

    if (enumType != 0B) goto <D.31757>; else goto <D.31758>;
    <D.31757>:
    <D.31758>:
    ex = mono_get_exception_argument_null ("enumType");
    mono_raise_exception (ex);
  }
  <D.31756>:
  D.31759 = value == 0B;
  D.31760 = (long int) D.31759;
  D.31761 = __builtin_expect (D.31760, 0);
  if (D.31761 != 0) goto <D.31762>; else goto <D.31763>;
  <D.31762>:
  {
    struct MonoException * ex;

    if (value != 0B) goto <D.31764>; else goto <D.31765>;
    <D.31764>:
    <D.31765>:
    ex = mono_get_exception_argument_null ("value");
    mono_raise_exception (ex);
  }
  <D.31763>:
  D.31766 = MEM[(struct MonoObject *)enumType].vtable;
  domain = D.31766->domain;
  D.31767 = enumType->type;
  enumc = mono_class_from_mono_type (D.31767);
  mono_class_init_or_throw (enumc);
  D.31768 = value->vtable;
  objc = D.31768->klass;
  D.31769 = BIT_FIELD_REF <*enumc, 64, 256>;
  D.31770 = D.31769 & 16;
  if (D.31770 == 0) goto <D.31771>; else goto <D.31772>;
  <D.31771>:
  D.31773 = mono_get_exception_argument ("enumType", "Type provided must be an Enum.");
  mono_raise_exception (D.31773);
  <D.31772>:
  D.31774 = BIT_FIELD_REF <*objc, 64, 256>;
  D.31775 = D.31774 & 16;
  if (D.31775 == 0) goto <D.31776>; else goto <D.31777>;
  <D.31776>:
  D.31778 = objc->byval_arg.type;
  D.31779 = D.31778 + 252;
  if (D.31779 > 7) goto <D.31780>; else goto <D.31781>;
  <D.31780>:
  D.31782 = mono_get_exception_argument ("value", "The value passed in must be an enum base or an underlying type for an enum, such as an Int32.");
  mono_raise_exception (D.31782);
  <D.31781>:
  <D.31777>:
  etype = mono_class_enum_basetype (enumc);
  if (etype == 0B) goto <D.31783>; else goto <D.31784>;
  <D.31783>:
  D.31785 = mono_get_exception_argument ("Type must be a type provided by the runtime.", "enumType");
  mono_raise_exception (D.31785);
  <D.31784>:
  res = mono_object_new (domain, enumc);
  D.31786 = value + 16;
  D.31774 = BIT_FIELD_REF <*objc, 64, 256>;
  D.31775 = D.31774 & 16;
  if (D.31775 != 0) goto <D.31788>; else goto <D.31789>;
  <D.31788>:
  D.31790 = mono_class_enum_basetype (objc);
  D.31791 = D.31790->type;
  iftmp.192 = (int) D.31791;
  goto <D.31792>;
  <D.31789>:
  D.31778 = objc->byval_arg.type;
  iftmp.192 = (int) D.31778;
  <D.31792>:
  val = read_enum_value (D.31786, iftmp.192);
  D.31793 = res + 16;
  D.31794 = etype->type;
  D.31795 = (int) D.31794;
  write_enum_value (D.31793, D.31795, val);
  D.31796 = res;
  return D.31796;
}


read_enum_value (char * mem, int type)
{
  guint64 D.31798;
  unsigned char D.31799;
  signed char D.31800;
  short unsigned int D.31801;
  short int D.31802;
  unsigned int D.31803;
  int D.31804;
  long int D.31805;

  switch (type) <default: <D.22496>, case 4: <D.22489>, case 5: <D.22488>, case 6: <D.22491>, case 7: <D.22490>, case 8: <D.22493>, case 9: <D.22492>, case 10: <D.22495>, case 11: <D.22494>>
  <D.22488>:
  D.31799 = MEM[(guint8 *)mem];
  D.31798 = (guint64) D.31799;
  return D.31798;
  <D.22489>:
  D.31800 = MEM[(gint8 *)mem];
  D.31798 = (guint64) D.31800;
  return D.31798;
  <D.22490>:
  D.31801 = MEM[(guint16 *)mem];
  D.31798 = (guint64) D.31801;
  return D.31798;
  <D.22491>:
  D.31802 = MEM[(gint16 *)mem];
  D.31798 = (guint64) D.31802;
  return D.31798;
  <D.22492>:
  D.31803 = MEM[(guint32 *)mem];
  D.31798 = (guint64) D.31803;
  return D.31798;
  <D.22493>:
  D.31804 = MEM[(gint32 *)mem];
  D.31798 = (guint64) D.31804;
  return D.31798;
  <D.22494>:
  D.31798 = MEM[(guint64 *)mem];
  return D.31798;
  <D.22495>:
  D.31805 = MEM[(gint64 *)mem];
  D.31798 = (guint64) D.31805;
  return D.31798;
  <D.22496>:
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "icall.c", 2997);
  D.31798 = 0;
  return D.31798;
}


write_enum_value (char * mem, int type, guint64 value)
{
  unsigned char D.31807;
  short unsigned int D.31808;
  unsigned int D.31809;

  switch (type) <default: <D.22515>, case 4: <D.22503>, case 5: <D.22502>, case 6: <D.22507>, case 7: <D.22506>, case 8: <D.22510>, case 9: <D.22509>, case 10: <D.22513>, case 11: <D.22512>>
  <D.22502>:
  <D.22503>:
  {
    guint8 * p;

    p = mem;
    D.31807 = (unsigned char) value;
    *p = D.31807;
    goto <D.22505>;
  }
  <D.22506>:
  <D.22507>:
  {
    guint16 * p;

    p = mem;
    D.31808 = (short unsigned int) value;
    *p = D.31808;
    goto <D.22505>;
  }
  <D.22509>:
  <D.22510>:
  {
    guint32 * p;

    p = mem;
    D.31809 = (unsigned int) value;
    *p = D.31809;
    goto <D.22505>;
  }
  <D.22512>:
  <D.22513>:
  {
    guint64 * p;

    p = mem;
    *p = value;
    goto <D.22505>;
  }
  <D.22515>:
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "icall.c", 3031);
  <D.22505>:
  return;
}


mono_double_ParseImpl (char * ptr, double * result)
{
  char D.31811;
  _Bool D.31816;
  long int D.31817;
  long int D.31818;
  double D.31821;
  _Bool D.31824;
  long int D.31825;
  long int D.31826;
  gchar * endptr.193;
  char D.31834;
  gboolean D.31835;
  gchar * endptr;

  try
    {
      endptr = 0B;
      *result = 0.0;
      D.31811 = *ptr;
      if (D.31811 != 0) goto <D.31812>; else goto <D.31813>;
      <D.31812>:
      {
        int ret;

        ret = pthread_mutex_lock (&mono_strtod_mutex.mutex);
        if (ret != 0) goto <D.31814>; else goto <D.31815>;
        <D.31814>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
        <D.31815>:
        D.31816 = ret != 0;
        D.31817 = (long int) D.31816;
        D.31818 = __builtin_expect (D.31817, 0);
        if (D.31818 != 0) goto <D.31819>; else goto <D.31820>;
        <D.31819>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "icall.c", 133, "ret == 0");
        <D.31820>:
      }
      D.31821 = mono_strtod (ptr, &endptr);
      *result = D.31821;
      {
        int ret;

        ret = pthread_mutex_unlock (&mono_strtod_mutex.mutex);
        if (ret != 0) goto <D.31822>; else goto <D.31823>;
        <D.31822>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
        <D.31823>:
        D.31824 = ret != 0;
        D.31825 = (long int) D.31824;
        D.31826 = __builtin_expect (D.31825, 0);
        if (D.31826 != 0) goto <D.31827>; else goto <D.31828>;
        <D.31827>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "icall.c", 135, "ret == 0");
        <D.31828>:
      }
      <D.31813>:
      D.31811 = *ptr;
      if (D.31811 == 0) goto <D.31829>; else goto <D.31831>;
      <D.31831>:
      endptr.193 = endptr;
      if (endptr.193 != 0B) goto <D.31833>; else goto <D.31830>;
      <D.31833>:
      endptr.193 = endptr;
      D.31834 = *endptr.193;
      if (D.31834 != 0) goto <D.31829>; else goto <D.31830>;
      <D.31829>:
      D.31835 = 0;
      return D.31835;
      <D.31830>:
      D.31835 = 1;
      return D.31835;
    }
  finally
    {
      endptr = {CLOBBER};
    }
}


ves_icall_System_Diagnostics_DefaultTraceListener_WriteWindowsDebugString (struct MonoString * message)
{
  monoeg_g_log (0B, 16, "WriteWindowsDebugString called and HOST_WIN32 not defined!\n");
}


ves_icall_System_Diagnostics_Debugger_Log (int level, struct MonoString * category, struct MonoString * message)
{
  struct MonoRuntimeCallbacks * D.31838;
  void (*<T282d>) (int, struct MonoString *, struct MonoString *) D.31839;
  struct MonoRuntimeCallbacks * D.31842;
  void (*<T282d>) (int, struct MonoString *, struct MonoString *) D.31843;

  D.31838 = mono_get_runtime_callbacks ();
  D.31839 = D.31838->debug_log;
  if (D.31839 != 0B) goto <D.31840>; else goto <D.31841>;
  <D.31840>:
  D.31842 = mono_get_runtime_callbacks ();
  D.31843 = D.31842->debug_log;
  D.31843 (level, category, message);
  <D.31841>:
}


ves_icall_System_Diagnostics_Debugger_IsLogging ()
{
  struct MonoRuntimeCallbacks * D.31844;
  gboolean (*<T2831>) (void) D.31845;
  MonoBoolean D.31848;
  struct MonoRuntimeCallbacks * D.31849;
  gboolean (*<T2831>) (void) D.31850;
  int D.31851;

  D.31844 = mono_get_runtime_callbacks ();
  D.31845 = D.31844->debug_log_is_enabled;
  if (D.31845 != 0B) goto <D.31846>; else goto <D.31847>;
  <D.31846>:
  D.31849 = mono_get_runtime_callbacks ();
  D.31850 = D.31849->debug_log_is_enabled;
  D.31851 = D.31850 ();
  D.31848 = (MonoBoolean) D.31851;
  return D.31848;
  <D.31847>:
  D.31848 = 0;
  return D.31848;
}


ves_icall_System_Diagnostics_Debugger_IsAttached_internal ()
{
  MonoBoolean D.31853;
  int D.31854;

  D.31854 = mono_is_debugger_attached ();
  D.31853 = (MonoBoolean) D.31854;
  return D.31853;
}


ves_icall_System_Delegate_SetMulticastInvoke (struct MonoDelegate * this)
{
  struct MonoVTable * D.31856;
  struct MonoClass * D.31857;
  void * D.31858;

  D.31856 = this->object.vtable;
  D.31857 = D.31856->klass;
  D.31858 = mono_runtime_create_delegate_trampoline (D.31857);
  this->invoke_impl = D.31858;
}


ves_icall_System_Delegate_CreateDelegate_internal (struct MonoReflectionType * type, struct MonoObject * target, struct MonoReflectionMethod * info, MonoBoolean throwOnBindFailure)
{
  struct MonoType * D.31859;
  struct MonoClass * D.31860;
  struct MonoClass * D.31861;
  <unnamed type> D.31864;
  int D.31867;
  int D.31868;
  struct MonoObject * D.31871;
  struct MonoVTable * D.31872;
  struct MonoDomain * D.31873;
  long unsigned int D.31874;
  long unsigned int D.31875;
  short unsigned int D.31881;
  int D.31882;
  int D.31883;
  struct MonoClass * D.31886;
  struct MonoVTable * D.31887;
  struct MonoClass * D.31888;
  struct MonoDomain * D.31891;
  struct MonoDomain * D.31892;
  void * D.31893;
  struct MonoClass * delegate_class;
  struct MonoObject * delegate;
  void * func;
  struct MonoMethod * method;
  static const char __PRETTY_FUNCTION__[50] = "ves_icall_System_Delegate_CreateDelegate_internal";

  D.31859 = type->type;
  delegate_class = mono_class_from_mono_type (D.31859);
  method = info->method;
  mono_class_init_or_throw (delegate_class);
  D.31860 = delegate_class->parent;
  D.31861 = mono_defaults.multicastdelegate_class;
  if (D.31860 != D.31861) goto <D.31862>; else goto <D.31863>;
  <D.31862>:
  {
    struct MonoException * ex;
    char * msg;

    msg = monoeg_g_strdup_printf ("file %s: line %d (%s): assertion failed: (%s)", "icall.c", 5817, &__PRETTY_FUNCTION__, "delegate_class->parent == mono_defaults.multicastdelegate_class");
    ex = mono_get_exception_execution_engine (msg);
    monoeg_g_free (msg);
    mono_raise_exception (ex);
  }
  <D.31863>:
  D.31864 = mono_security_get_mode ();
  if (D.31864 == 1) goto <D.31865>; else goto <D.31866>;
  <D.31865>:
  D.31867 = (int) throwOnBindFailure;
  D.31868 = mono_security_core_clr_ensure_delegate_creation (method, D.31867);
  if (D.31868 == 0) goto <D.31869>; else goto <D.31870>;
  <D.31869>:
  D.31871 = 0B;
  return D.31871;
  <D.31870>:
  <D.31866>:
  D.31872 = MEM[(struct MonoObject *)type].vtable;
  D.31873 = D.31872->domain;
  delegate = mono_object_new (D.31873, delegate_class);
  D.31874 = BIT_FIELD_REF <*method, 64, 256>;
  D.31875 = D.31874 & 512;
  if (D.31875 != 0) goto <D.31876>; else goto <D.31877>;
  <D.31876>:
  func = mono_compile_method (method);
  goto <D.31878>;
  <D.31877>:
  if (target != 0B) goto <D.31879>; else goto <D.31880>;
  <D.31879>:
  D.31881 = method->flags;
  D.31882 = (int) D.31881;
  D.31883 = D.31882 & 64;
  if (D.31883 != 0) goto <D.31884>; else goto <D.31885>;
  <D.31884>:
  D.31886 = method->klass;
  D.31887 = target->vtable;
  D.31888 = D.31887->klass;
  if (D.31886 != D.31888) goto <D.31889>; else goto <D.31890>;
  <D.31889>:
  method = mono_object_get_virtual_method (target, method);
  <D.31890>:
  <D.31885>:
  <D.31880>:
  D.31891 = mono_domain_get ();
  D.31892 = mono_domain_get ();
  D.31893 = mono_runtime_create_jump_trampoline (D.31892, method, 1);
  func = mono_create_ftnptr (D.31891, D.31893);
  <D.31878>:
  mono_delegate_ctor_with_method (delegate, target, func, method);
  D.31871 = delegate;
  return D.31871;
}


ves_icall_System_CurrentSystemTimeZone_GetTimeZoneData (guint32 year, struct MonoArray * * data, struct MonoArray * * names)
{
  _Bool D.31895;
  long int D.31896;
  long int D.31897;
  _Bool D.31902;
  long int D.31903;
  long int D.31904;
  struct MonoClass * D.31909;
  struct MonoArray * D.31910;
  struct MonoClass * D.31911;
  struct MonoArray * D.31912;
  unsigned int D.31913;
  int D.31914;
  long int t.194;
  unsigned int D.31918;
  long int t.195;
  long int t.196;
  struct tm * D.31922;
  struct MonoArray * D.31923;
  struct MonoString * D.31924;
  struct MonoString * D.31925;
  guint32 D.31926;
  int D.31927;
  long int t.197;
  struct tm * D.31929;
  int D.31930;
  long int t1.198;
  long int t1.199;
  struct tm * D.31935;
  int D.31936;
  long int D.31937;
  long int t1.200;
  struct tm * D.31939;
  int D.31940;
  long int D.31941;
  long int t1.201;
  int D.31943;
  struct MonoString * D.31946;
  struct MonoArray * D.31947;
  long unsigned int t1.202;
  long unsigned int D.31949;
  long unsigned int D.31950;
  long int D.31951;
  struct MonoString * D.31955;
  int D.31958;
  long int D.31961;
  long int D.31962;
  long int D.31963;
  int D.31964;
  struct MonoString * D.31968;
  struct MonoString * D.31969;
  long int D.31970;
  struct MonoDomain * domain;
  struct tm start;
  struct tm tt;
  time_t t;
  long int gmtoff;
  long int gmtoff_after;
  long int gmtoff_st;
  long int gmtoff_ds;
  int day;
  int transitioned;
  char tzone[64];

  try
    {
      domain = mono_domain_get ();
      transitioned = 0;
      gmtoff_ds = 0;
      gmtoff_st = gmtoff_ds;
      D.31895 = data == 0B;
      D.31896 = (long int) D.31895;
      D.31897 = __builtin_expect (D.31896, 0);
      if (D.31897 != 0) goto <D.31898>; else goto <D.31899>;
      <D.31898>:
      {
        struct MonoException * ex;

        if (data != 0B) goto <D.31900>; else goto <D.31901>;
        <D.31900>:
        <D.31901>:
        ex = mono_get_exception_argument_null ("data");
        mono_raise_exception (ex);
      }
      <D.31899>:
      D.31902 = names == 0B;
      D.31903 = (long int) D.31902;
      D.31904 = __builtin_expect (D.31903, 0);
      if (D.31904 != 0) goto <D.31905>; else goto <D.31906>;
      <D.31905>:
      {
        struct MonoException * ex;

        if (names != 0B) goto <D.31907>; else goto <D.31908>;
        <D.31907>:
        <D.31908>:
        ex = mono_get_exception_argument_null ("names");
        mono_raise_exception (ex);
      }
      <D.31906>:
      D.31909 = mono_defaults.int64_class;
      D.31910 = mono_array_new (domain, D.31909, 4);
      mono_gc_wbarrier_generic_store (data, D.31910);
      D.31911 = mono_defaults.string_class;
      D.31912 = mono_array_new (domain, D.31911, 2);
      mono_gc_wbarrier_generic_store (names, D.31912);
      memset (&start, 0, 56);
      start.tm_mday = 1;
      D.31913 = year + 4294965396;
      D.31914 = (int) D.31913;
      start.tm_year = D.31914;
      t.194 = mktime (&start);
      t = t.194;
      D.31918 = year + 4294965326;
      if (D.31918 > 67) goto <D.31916>; else goto <D.31919>;
      <D.31919>:
      t.195 = t;
      if (t.195 == -1) goto <D.31916>; else goto <D.31917>;
      <D.31916>:
      t.196 = time (0B);
      t = t.196;
      D.31922 = localtime (&t);
      tt = *D.31922;
      strftime (&tzone, 64, "%Z", &tt);
      {
        void * * __p;

        D.31923 = *names;
        __p = mono_array_addr_with_size (D.31923, 8, 0);
        D.31923 = *names;
        D.31924 = mono_string_new (domain, &tzone);
        mono_gc_wbarrier_set_arrayref (D.31923, __p, D.31924);
      }
      {
        void * * __p;

        D.31923 = *names;
        __p = mono_array_addr_with_size (D.31923, 8, 1);
        D.31923 = *names;
        D.31925 = mono_string_new (domain, &tzone);
        mono_gc_wbarrier_set_arrayref (D.31923, __p, D.31925);
      }
      D.31926 = 1;
      return D.31926;
      <D.31917>:
      t.195 = t;
      D.31927 = gmt_offset (&start, t.195);
      gmtoff = (long int) D.31927;
      day = 0;
      goto <D.23659>;
      <D.23658>:
      t.195 = t;
      t.197 = t.195 + 86400;
      t = t.197;
      D.31929 = localtime (&t);
      tt = *D.31929;
      t.195 = t;
      D.31930 = gmt_offset (&tt, t.195);
      gmtoff_after = (long int) D.31930;
      if (gmtoff_after != gmtoff) goto <D.31931>; else goto <D.31932>;
      <D.31931>:
      {
        struct tm tt1;
        time_t t1;

        try
          {
            t.195 = t;
            t1 = t.195;
            <D.23647>:
            t1.198 = t1;
            t1.199 = t1.198 + -3600;
            t1 = t1.199;
            D.31935 = localtime (&t1);
            tt1 = *D.31935;
            t1.198 = t1;
            D.31936 = gmt_offset (&tt1, t1.198);
            D.31937 = (long int) D.31936;
            if (D.31937 != gmtoff) goto <D.23647>; else goto <D.23648>;
            <D.23648>:
            <D.23649>:
            t1.198 = t1;
            t1.200 = t1.198 + 60;
            t1 = t1.200;
            D.31939 = localtime (&t1);
            tt1 = *D.31939;
            t1.198 = t1;
            D.31940 = gmt_offset (&tt1, t1.198);
            D.31941 = (long int) D.31940;
            if (D.31941 == gmtoff) goto <D.23649>; else goto <D.23650>;
            <D.23650>:
            t1.198 = t1;
            t1.201 = t1.198 + gmtoff;
            t1 = t1.201;
            strftime (&tzone, 64, "%Z", &tt);
            D.31943 = tt.tm_isdst;
            if (D.31943 != 0) goto <D.31944>; else goto <D.31945>;
            <D.31944>:
            {
              void * * __p;

              D.31923 = *names;
              __p = mono_array_addr_with_size (D.31923, 8, 1);
              D.31923 = *names;
              D.31946 = mono_string_new (domain, &tzone);
              mono_gc_wbarrier_set_arrayref (D.31923, __p, D.31946);
            }
            {
              gint64 * __p;

              D.31947 = *data;
              __p = mono_array_addr_with_size (D.31947, 8, 0);
              t1.198 = t1;
              t1.202 = (long unsigned int) t1.198;
              D.31949 = t1.202 * 10000000;
              D.31950 = D.31949 + 621355968000000000;
              D.31951 = (long int) D.31950;
              *__p = D.31951;
            }
            if (gmtoff_ds == 0) goto <D.31952>; else goto <D.31953>;
            <D.31952>:
            gmtoff_st = gmtoff;
            gmtoff_ds = gmtoff_after;
            <D.31953>:
            transitioned = transitioned + 1;
            goto <D.31954>;
            <D.31945>:
            {
              time_t te;

              te = mktime (&tt);
              {
                void * * __p;

                D.31923 = *names;
                __p = mono_array_addr_with_size (D.31923, 8, 0);
                D.31923 = *names;
                D.31955 = mono_string_new (domain, &tzone);
                mono_gc_wbarrier_set_arrayref (D.31923, __p, D.31955);
              }
              {
                gint64 * __p;

                D.31947 = *data;
                __p = mono_array_addr_with_size (D.31947, 8, 1);
                t1.198 = t1;
                t1.202 = (long unsigned int) t1.198;
                D.31949 = t1.202 * 10000000;
                D.31950 = D.31949 + 621355968000000000;
                D.31951 = (long int) D.31950;
                *__p = D.31951;
              }
              if (gmtoff_ds == 0) goto <D.31956>; else goto <D.31957>;
              <D.31956>:
              gmtoff_st = gmtoff_after;
              gmtoff_ds = gmtoff;
              <D.31957>:
              transitioned = transitioned + 1;
            }
            <D.31954>:
            D.31958 = tt1.tm_isdst;
            if (D.31958 != 0) goto <D.31959>; else goto <D.31960>;
            <D.31959>:
            {
              gint64 * __p;

              D.31947 = *data;
              __p = mono_array_addr_with_size (D.31947, 8, 2);
              D.31961 = gmtoff_st * 10000000;
              *__p = D.31961;
            }
            {
              gint64 * __p;

              D.31947 = *data;
              __p = mono_array_addr_with_size (D.31947, 8, 3);
              D.31962 = gmtoff_ds - gmtoff_st;
              D.31963 = D.31962 * 10000000;
              *__p = D.31963;
            }
            <D.31960>:
            t.195 = t;
            D.31964 = gmt_offset (&tt, t.195);
            gmtoff = (long int) D.31964;
          }
        finally
          {
            tt1 = {CLOBBER};
            t1 = {CLOBBER};
          }
      }
      <D.31932>:
      day = day + 1;
      <D.23659>:
      if (day <= 364) goto <D.31965>; else goto <D.23660>;
      <D.31965>:
      if (transitioned <= 1) goto <D.23658>; else goto <D.23660>;
      <D.23660>:
      if (transitioned <= 1) goto <D.31966>; else goto <D.31967>;
      <D.31966>:
      strftime (&tzone, 64, "%Z", &tt);
      {
        void * * __p;

        D.31923 = *names;
        __p = mono_array_addr_with_size (D.31923, 8, 0);
        D.31923 = *names;
        D.31968 = mono_string_new (domain, &tzone);
        mono_gc_wbarrier_set_arrayref (D.31923, __p, D.31968);
      }
      {
        void * * __p;

        D.31923 = *names;
        __p = mono_array_addr_with_size (D.31923, 8, 1);
        D.31923 = *names;
        D.31969 = mono_string_new (domain, &tzone);
        mono_gc_wbarrier_set_arrayref (D.31923, __p, D.31969);
      }
      {
        gint64 * __p;

        D.31947 = *data;
        __p = mono_array_addr_with_size (D.31947, 8, 0);
        *__p = 0;
      }
      {
        gint64 * __p;

        D.31947 = *data;
        __p = mono_array_addr_with_size (D.31947, 8, 1);
        *__p = 0;
      }
      {
        gint64 * __p;

        D.31947 = *data;
        __p = mono_array_addr_with_size (D.31947, 8, 2);
        D.31970 = gmtoff * 10000000;
        *__p = D.31970;
      }
      {
        gint64 * __p;

        D.31947 = *data;
        __p = mono_array_addr_with_size (D.31947, 8, 3);
        *__p = 0;
      }
      <D.31967>:
      D.31926 = 1;
      return D.31926;
    }
  finally
    {
      start = {CLOBBER};
      tt = {CLOBBER};
      t = {CLOBBER};
      tzone = {CLOBBER};
    }
}


gmt_offset (struct tm * tm, time_t t)
{
  int D.31973;
  long int D.31974;

  D.31974 = tm->tm_gmtoff;
  D.31973 = (int) D.31974;
  return D.31973;
}


InternalFromBase64String (struct MonoString * str, MonoBoolean allowWhitespaceOnly)
{
  struct MonoArray * D.31976;
  mono_unichar2 * D.31977;
  int D.31978;

  D.31977 = mono_string_chars (str);
  D.31978 = mono_string_length (str);
  D.31976 = base64_to_byte_array (D.31977, D.31978, allowWhitespaceOnly);
  return D.31976;
}


base64_to_byte_array (gunichar2 * start, gint ilength, MonoBoolean allowWhitespaceOnly)
{
  long unsigned int D.31980;
  long unsigned int D.31981;
  gunichar2 * D.31982;
  struct MonoImage * D.31985;
  const short unsigned int * * D.31987;
  const short unsigned int * D.31988;
  long unsigned int D.31989;
  long unsigned int D.31990;
  const short unsigned int * D.31991;
  short unsigned int D.31992;
  int D.31993;
  int D.31994;
  struct MonoImage * D.32002;
  struct MonoArray * D.32009;
  struct MonoDomain * D.32010;
  struct MonoClass * D.32011;
  int D.32014;
  struct MonoImage * D.32016;
  struct MonoImage * D.32019;
  int D.32020;
  struct MonoDomain * D.32025;
  long unsigned int D.32026;
  int i.203;
  long unsigned int D.32028;
  long unsigned int D.32029;
  gunichar2 * D.32030;
  unsigned char D.32033;
  int D.32034;
  int D.32035;
  unsigned char D.32036;
  int D.32037;
  int D.32038;
  int D.32039;
  struct MonoImage * D.32042;
  guchar * res_ptr.204;
  int D.32045;
  int D.32046;
  signed char D.32047;
  int D.32048;
  int D.32049;
  signed char D.32050;
  signed char D.32051;
  unsigned char D.32052;
  int D.32053;
  guchar * res_ptr.205;
  int D.32057;
  signed char D.32058;
  int D.32059;
  int D.32060;
  signed char D.32061;
  signed char D.32062;
  unsigned char D.32063;
  int D.32064;
  guchar * res_ptr.206;
  int D.32068;
  signed char D.32069;
  int D.32070;
  signed char D.32071;
  signed char D.32072;
  unsigned char D.32073;
  short unsigned int D.32075;
  long unsigned int D.32076;
  long unsigned int D.32077;
  const short unsigned int * D.32078;
  short unsigned int D.32079;
  int D.32080;
  int D.32081;
  gint ignored;
  gint i;
  gunichar2 c;
  gunichar2 last;
  gunichar2 prev_last;
  gunichar2 prev2_last;
  gint olength;
  struct MonoArray * result;
  guchar * res_ptr;
  gint a[4];
  gint b[4];
  struct MonoException * exc;
  int havePadding;

  try
    {
      havePadding = 0;
      ignored = 0;
      prev_last = 0;
      last = prev_last;
      prev2_last = 0;
      i = 0;
      goto <D.24171>;
      <D.24170>:
      D.31980 = (long unsigned int) i;
      D.31981 = D.31980 * 2;
      D.31982 = start + D.31981;
      c = *D.31982;
      if (c > 122) goto <D.31983>; else goto <D.31984>;
      <D.31983>:
      D.31985 = mono_get_corlib ();
      exc = mono_exception_from_name_msg (D.31985, "System", "FormatException", "Invalid character found.");
      mono_raise_exception (exc);
      goto <D.31986>;
      <D.31984>:
      D.31987 = __ctype_b_loc ();
      D.31988 = *D.31987;
      D.31989 = (long unsigned int) c;
      D.31990 = D.31989 * 2;
      D.31991 = D.31988 + D.31990;
      D.31992 = *D.31991;
      D.31993 = (int) D.31992;
      D.31994 = D.31993 & 8192;
      if (D.31994 != 0) goto <D.31995>; else goto <D.31996>;
      <D.31995>:
      ignored = ignored + 1;
      goto <D.31997>;
      <D.31996>:
      if (havePadding != 0) goto <D.32000>; else goto <D.31998>;
      <D.32000>:
      if (c != 61) goto <D.32001>; else goto <D.31998>;
      <D.32001>:
      D.32002 = mono_get_corlib ();
      exc = mono_exception_from_name_msg (D.32002, "System", "FormatException", "Invalid character found.");
      mono_raise_exception (exc);
      goto <D.31999>;
      <D.31998>:
      if (c == 61) goto <D.32003>; else goto <D.32004>;
      <D.32003>:
      havePadding = 1;
      <D.32004>:
      prev2_last = prev_last;
      prev_last = last;
      last = c;
      <D.31999>:
      <D.31997>:
      <D.31986>:
      i = i + 1;
      <D.24171>:
      if (i < ilength) goto <D.24170>; else goto <D.24172>;
      <D.24172>:
      olength = ilength - ignored;
      if (allowWhitespaceOnly != 0) goto <D.32005>; else goto <D.32006>;
      <D.32005>:
      if (olength == 0) goto <D.32007>; else goto <D.32008>;
      <D.32007>:
      D.32010 = mono_domain_get ();
      D.32011 = mono_defaults.byte_class;
      D.32009 = mono_array_new (D.32010, D.32011, 0);
      return D.32009;
      <D.32008>:
      <D.32006>:
      D.32014 = olength & 3;
      if (D.32014 != 0) goto <D.32012>; else goto <D.32015>;
      <D.32015>:
      if (olength <= 0) goto <D.32012>; else goto <D.32013>;
      <D.32012>:
      D.32016 = mono_get_corlib ();
      exc = mono_exception_from_name_msg (D.32016, "System", "FormatException", "Invalid length.");
      mono_raise_exception (exc);
      <D.32013>:
      if (prev2_last == 61) goto <D.32017>; else goto <D.32018>;
      <D.32017>:
      D.32019 = mono_get_corlib ();
      exc = mono_exception_from_name_msg (D.32019, "System", "FormatException", "Invalid format.");
      mono_raise_exception (exc);
      <D.32018>:
      D.32020 = olength * 3;
      olength = D.32020 / 4;
      if (last == 61) goto <D.32021>; else goto <D.32022>;
      <D.32021>:
      olength = olength + -1;
      <D.32022>:
      if (prev_last == 61) goto <D.32023>; else goto <D.32024>;
      <D.32023>:
      olength = olength + -1;
      <D.32024>:
      D.32025 = mono_domain_get ();
      D.32011 = mono_defaults.byte_class;
      D.32026 = (long unsigned int) olength;
      result = mono_array_new (D.32025, D.32011, D.32026);
      res_ptr = mono_array_addr_with_size (result, 1, 0);
      i = 0;
      goto <D.24181>;
      <D.24180>:
      {
        int k;

        k = 0;
        goto <D.24174>;
        <D.24175>:
        i.203 = i;
        i = i.203 + 1;
        D.32028 = (long unsigned int) i.203;
        D.32029 = D.32028 * 2;
        D.32030 = start + D.32029;
        c = *D.32030;
        D.31987 = __ctype_b_loc ();
        D.31988 = *D.31987;
        D.31989 = (long unsigned int) c;
        D.31990 = D.31989 * 2;
        D.31991 = D.31988 + D.31990;
        D.31992 = *D.31991;
        D.31993 = (int) D.31992;
        D.31994 = D.31993 & 8192;
        if (D.31994 != 0) goto <D.32031>; else goto <D.32032>;
        <D.32031>:
        // predicted unlikely by continue predictor.
        goto <D.24174>;
        <D.32032>:
        D.32033 = (unsigned char) c;
        D.32034 = (int) D.32033;
        a[k] = D.32034;
        D.32035 = (int) c;
        D.32036 = dbase64[D.32035];
        D.32037 = (int) D.32036;
        b[k] = D.32037;
        D.32038 = b[k];
        D.32039 = D.32038 & 128;
        if (D.32039 != 0) goto <D.32040>; else goto <D.32041>;
        <D.32040>:
        D.32042 = mono_get_corlib ();
        exc = mono_exception_from_name_msg (D.32042, "System", "FormatException", "Invalid character found.");
        mono_raise_exception (exc);
        <D.32041>:
        k = k + 1;
        <D.24174>:
        if (k <= 3) goto <D.32043>; else goto <D.24176>;
        <D.32043>:
        if (i < ilength) goto <D.24175>; else goto <D.24176>;
        <D.24176>:
        res_ptr.204 = res_ptr;
        res_ptr = res_ptr.204 + 1;
        D.32045 = b[0];
        D.32046 = D.32045 << 2;
        D.32047 = (signed char) D.32046;
        D.32048 = b[1];
        D.32049 = D.32048 >> 4;
        D.32050 = (signed char) D.32049;
        D.32051 = D.32047 | D.32050;
        D.32052 = (unsigned char) D.32051;
        *res_ptr.204 = D.32052;
        D.32053 = a[2];
        if (D.32053 != 61) goto <D.32054>; else goto <D.32055>;
        <D.32054>:
        res_ptr.205 = res_ptr;
        res_ptr = res_ptr.205 + 1;
        D.32048 = b[1];
        D.32057 = D.32048 << 4;
        D.32058 = (signed char) D.32057;
        D.32059 = b[2];
        D.32060 = D.32059 >> 2;
        D.32061 = (signed char) D.32060;
        D.32062 = D.32058 | D.32061;
        D.32063 = (unsigned char) D.32062;
        *res_ptr.205 = D.32063;
        <D.32055>:
        D.32064 = a[3];
        if (D.32064 != 61) goto <D.32065>; else goto <D.32066>;
        <D.32065>:
        res_ptr.206 = res_ptr;
        res_ptr = res_ptr.206 + 1;
        D.32059 = b[2];
        D.32068 = D.32059 << 6;
        D.32069 = (signed char) D.32068;
        D.32070 = b[3];
        D.32071 = (signed char) D.32070;
        D.32072 = D.32069 | D.32071;
        D.32073 = (unsigned char) D.32072;
        *res_ptr.206 = D.32073;
        <D.32066>:
        goto <D.24178>;
        <D.24177>:
        i = i + 1;
        <D.24178>:
        if (i < ilength) goto <D.32074>; else goto <D.24179>;
        <D.32074>:
        D.31987 = __ctype_b_loc ();
        D.31988 = *D.31987;
        D.31980 = (long unsigned int) i;
        D.31981 = D.31980 * 2;
        D.31982 = start + D.31981;
        D.32075 = *D.31982;
        D.32076 = (long unsigned int) D.32075;
        D.32077 = D.32076 * 2;
        D.32078 = D.31988 + D.32077;
        D.32079 = *D.32078;
        D.32080 = (int) D.32079;
        D.32081 = D.32080 & 8192;
        if (D.32081 != 0) goto <D.24177>; else goto <D.24179>;
        <D.24179>:
      }
      <D.24181>:
      if (i < ilength) goto <D.24180>; else goto <D.24182>;
      <D.24182>:
      D.32009 = result;
      return D.32009;
    }
  finally
    {
      a = {CLOBBER};
      b = {CLOBBER};
    }
}


InternalFromBase64CharArray (struct MonoArray * input, gint offset, gint length)
{
  struct MonoArray * D.32084;
  long unsigned int D.32085;
  char * D.32086;

  D.32085 = (long unsigned int) offset;
  D.32086 = mono_array_addr_with_size (input, 2, D.32085);
  D.32084 = base64_to_byte_array (D.32086, length, 0);
  return D.32084;
}


get_bundled_app_config ()
{
  struct MonoAppDomainSetup * D.32088;
  struct MonoString * D.32091;
  long unsigned int D.32094;
  long unsigned int D.32095;
  struct MonoDomain * D.32100;
  const gchar * app_config;
  struct MonoDomain * domain;
  struct MonoString * file;
  gchar * config_file_name;
  gchar * config_file_path;
  gsize len;
  gchar * module;

  domain = mono_domain_get ();
  D.32088 = domain->setup;
  file = D.32088->configuration_file;
  if (file == 0B) goto <D.32089>; else goto <D.32090>;
  <D.32089>:
  D.32091 = 0B;
  return D.32091;
  <D.32090>:
  config_file_name = mono_string_to_utf8 (file);
  config_file_path = mono_portability_find_file (config_file_name, 1);
  if (config_file_path == 0B) goto <D.32092>; else goto <D.32093>;
  <D.32092>:
  config_file_path = config_file_name;
  <D.32093>:
  D.32094 = strlen (config_file_path);
  len = D.32094 + 18446744073709551609;
  D.32095 = len + 1;
  module = monoeg_malloc0 (D.32095);
  memcpy (module, config_file_path, len);
  app_config = mono_config_string_for_assembly_file (module);
  monoeg_g_free (module);
  if (config_file_name != config_file_path) goto <D.32096>; else goto <D.32097>;
  <D.32096>:
  monoeg_g_free (config_file_name);
  <D.32097>:
  monoeg_g_free (config_file_path);
  if (app_config == 0B) goto <D.32098>; else goto <D.32099>;
  <D.32098>:
  D.32091 = 0B;
  return D.32091;
  <D.32099>:
  D.32100 = mono_domain_get ();
  D.32091 = mono_string_new (D.32100, app_config);
  return D.32091;
}


ves_icall_System_Configuration_DefaultConfig_get_machine_config_path ()
{
  const char * D.32102;
  const struct MonoRuntimeInfo * D.32103;
  const char[4] * D.32104;
  struct MonoDomain * D.32105;
  struct MonoString * D.32106;
  struct MonoString * mcpath;
  gchar * path;

  D.32102 = mono_get_config_dir ();
  D.32103 = mono_get_runtime_info ();
  D.32104 = &D.32103->framework_version;
  path = monoeg_g_build_path ("/", D.32102, "mono", D.32104, "machine.config", 0B);
  D.32105 = mono_domain_get ();
  mcpath = mono_string_new (D.32105, path);
  monoeg_g_free (path);
  D.32106 = mcpath;
  return D.32106;
}


get_bundled_machine_config ()
{
  struct MonoString * D.32110;
  struct MonoDomain * D.32111;
  const gchar * machine_config;

  machine_config = mono_get_machine_config ();
  if (machine_config == 0B) goto <D.32108>; else goto <D.32109>;
  <D.32108>:
  D.32110 = 0B;
  return D.32110;
  <D.32109>:
  D.32111 = mono_domain_get ();
  D.32110 = mono_string_new (D.32111, machine_config);
  return D.32110;
}


ves_icall_System_ComponentModel_Win32Exception_W32ErrorMessage (guint32 code)
{
  struct MonoDomain * D.32115;
  struct MonoDomain * D.32117;
  int ret.207;
  struct MonoString * D.32119;
  struct MonoString * message;
  guint32 ret;
  gunichar2 buf[256];

  try
    {
      ret = FormatMessage (4608, 0B, code, 0, &buf, 255, 0B);
      if (ret == 0) goto <D.32113>; else goto <D.32114>;
      <D.32113>:
      D.32115 = mono_domain_get ();
      message = mono_string_new (D.32115, "Error looking up error string");
      goto <D.32116>;
      <D.32114>:
      D.32117 = mono_domain_get ();
      ret.207 = (int) ret;
      message = mono_string_new_utf16 (D.32117, &buf, ret.207);
      <D.32116>:
      D.32119 = message;
      return D.32119;
    }
  finally
    {
      buf = {CLOBBER};
    }
}


ves_icall_System_Char_GetDataTablePointers (int category_data_version, const guint8 * * category_data, const guint16 * * category_astral_index, const guint8 * * numeric_data, const gdouble * * numeric_data_values, const guint16 * * to_lower_data_low, const guint16 * * to_lower_data_high, const guint16 * * to_upper_data_low, const guint16 * * to_upper_data_high)
{
  get_category_data (category_data_version, category_data, category_astral_index);
  *numeric_data = &NumericData;
  *numeric_data_values = &NumericDataValues;
  *to_lower_data_low = &ToLowerDataLow;
  *to_lower_data_high = &ToLowerDataHigh;
  *to_upper_data_low = &ToUpperDataLow;
  *to_upper_data_high = &ToUpperDataHigh;
}


get_category_data (int version, const guint8 * * category_data, const guint16 * * category_astral_index)
{
  *category_astral_index = 0B;
  if (version == 4) goto <D.32122>; else goto <D.32123>;
  <D.32122>:
  *category_data = &CategoryData_v4;
  *category_astral_index = &CategoryData_v4_astral_index;
  return;
  <D.32123>:
  *category_data = &CategoryData_v2;
  *category_astral_index = &CategoryData_v2_astral_index;
}


ves_icall_System_Buffer_SetByteInternal (struct MonoArray * array, gint32 idx, gint8 value)
{
  long unsigned int D.32125;

  {
    gint8 * __p;

    D.32125 = (long unsigned int) idx;
    __p = mono_array_addr_with_size (array, 1, D.32125);
    *__p = value;
  }
}


ves_icall_System_Buffer_GetByteInternal (struct MonoArray * array, gint32 idx)
{
  gint8 D.32126;
  long unsigned int D.32127;
  char * D.32128;

  D.32127 = (long unsigned int) idx;
  D.32128 = mono_array_addr_with_size (array, 1, D.32127);
  D.32126 = MEM[(gint8 *)D.32128];
  return D.32126;
}


ves_icall_System_Buffer_ByteLengthInternal (struct MonoArray * array)
{
  gint32 D.32130;

  D.32130 = mono_array_get_byte_length (array);
  return D.32130;
}


mono_array_get_byte_length (struct MonoArray * array)
{
  struct MonoVTable * D.32132;
  struct MonoArrayBounds * D.32133;
  unsigned int D.32136;
  long unsigned int D.32138;
  long unsigned int D.32139;
  struct MonoArrayBounds * D.32140;
  unsigned int D.32141;
  unsigned int length.208;
  unsigned int D.32143;
  unsigned char D.32144;
  int D.32145;
  struct MonoClass * D.32146;
  unsigned char D.32147;
  int D.32148;
  gint32 D.32149;
  unsigned int length.209;
  unsigned int D.32151;
  struct MonoClass * klass;
  int length;
  int i;

  D.32132 = array->obj.vtable;
  klass = D.32132->klass;
  D.32133 = array->bounds;
  if (D.32133 == 0B) goto <D.32134>; else goto <D.32135>;
  <D.32134>:
  D.32136 = array->max_length;
  length = (int) D.32136;
  goto <D.32137>;
  <D.32135>:
  length = 1;
  i = 0;
  goto <D.23677>;
  <D.23676>:
  D.32133 = array->bounds;
  D.32138 = (long unsigned int) i;
  D.32139 = D.32138 * 8;
  D.32140 = D.32133 + D.32139;
  D.32141 = D.32140->length;
  length.208 = (unsigned int) length;
  D.32143 = D.32141 * length.208;
  length = (int) D.32143;
  i = i + 1;
  <D.23677>:
  D.32144 = klass->rank;
  D.32145 = (int) D.32144;
  if (D.32145 > i) goto <D.23676>; else goto <D.23678>;
  <D.23678>:
  <D.32137>:
  D.32146 = klass->element_class;
  D.32147 = D.32146->byval_arg.type;
  D.32148 = (int) D.32147;
  switch (D.32148) <default: <D.23693>, case 2: <D.23681>, case 3: <D.23684>, case 4: <D.23679>, case 5: <D.23680>, case 6: <D.23682>, case 7: <D.23683>, case 8: <D.23685>, case 9: <D.23686>, case 10: <D.23690>, case 11: <D.23691>, case 12: <D.23687>, case 13: <D.23692>, case 24: <D.23688>, case 25: <D.23689>>
  <D.23679>:
  <D.23680>:
  <D.23681>:
  D.32149 = length;
  return D.32149;
  <D.23682>:
  <D.23683>:
  <D.23684>:
  D.32149 = length << 1;
  return D.32149;
  <D.23685>:
  <D.23686>:
  <D.23687>:
  D.32149 = length << 2;
  return D.32149;
  <D.23688>:
  <D.23689>:
  length.209 = (unsigned int) length;
  D.32151 = length.209 * 8;
  D.32149 = (gint32) D.32151;
  return D.32149;
  <D.23690>:
  <D.23691>:
  <D.23692>:
  D.32149 = length << 3;
  return D.32149;
  <D.23693>:
  D.32149 = -1;
  return D.32149;
}


ves_icall_System_Buffer_BlockCopyInternal (struct MonoArray * src, gint32 src_offset, struct MonoArray * dest, gint32 dest_offset, gint32 count)
{
  _Bool D.32153;
  long int D.32154;
  long int D.32155;
  _Bool D.32160;
  long int D.32161;
  long int D.32162;
  int D.32169;
  int D.32170;
  int D.32172;
  int D.32173;
  MonoBoolean D.32174;
  double[0:] * D.32175;
  sizetype D.32176;
  double[0:] * D.32177;
  sizetype D.32178;
  long unsigned int D.32181;
  guint8 * src_buf;
  guint8 * dest_buf;

  D.32153 = src == 0B;
  D.32154 = (long int) D.32153;
  D.32155 = __builtin_expect (D.32154, 0);
  if (D.32155 != 0) goto <D.32156>; else goto <D.32157>;
  <D.32156>:
  {
    struct MonoException * ex;

    if (src != 0B) goto <D.32158>; else goto <D.32159>;
    <D.32158>:
    <D.32159>:
    ex = mono_get_exception_argument_null ("src");
    mono_raise_exception (ex);
  }
  <D.32157>:
  D.32160 = dest == 0B;
  D.32161 = (long int) D.32160;
  D.32162 = __builtin_expect (D.32161, 0);
  if (D.32162 != 0) goto <D.32163>; else goto <D.32164>;
  <D.32163>:
  {
    struct MonoException * ex;

    if (dest != 0B) goto <D.32165>; else goto <D.32166>;
    <D.32165>:
    <D.32166>:
    ex = mono_get_exception_argument_null ("dest");
    mono_raise_exception (ex);
  }
  <D.32164>:
  D.32169 = mono_array_get_byte_length (src);
  D.32170 = D.32169 - count;
  if (D.32170 < src_offset) goto <D.32167>; else goto <D.32171>;
  <D.32171>:
  D.32172 = mono_array_get_byte_length (dest);
  D.32173 = D.32172 - count;
  if (D.32173 < dest_offset) goto <D.32167>; else goto <D.32168>;
  <D.32167>:
  D.32174 = 0;
  return D.32174;
  <D.32168>:
  D.32175 = &src->vector;
  D.32176 = (sizetype) src_offset;
  src_buf = D.32175 + D.32176;
  D.32177 = &dest->vector;
  D.32178 = (sizetype) dest_offset;
  dest_buf = D.32177 + D.32178;
  if (src != dest) goto <D.32179>; else goto <D.32180>;
  <D.32179>:
  D.32181 = (long unsigned int) count;
  memcpy (dest_buf, src_buf, D.32181);
  goto <D.32182>;
  <D.32180>:
  D.32181 = (long unsigned int) count;
  memmove (dest_buf, src_buf, D.32181);
  <D.32182>:
  D.32174 = 1;
  return D.32174;
}


memmove (void * __dest, const void * __src, size_t __len)
{
  void * D.32184;
  long unsigned int D.32185;

  D.32185 = __builtin_object_size (__dest, 0);
  D.32184 = __builtin___memmove_chk (__dest, __src, __len, D.32185);
  return D.32184;
}


ves_icall_System_Array_SetValueImpl (struct MonoArray * this, struct MonoObject * value, guint32 pos)
{
  struct MonoVTable * D.32189;
  struct MonoVTable * D.32191;
  double[0:] * D.32192;
  unsigned int esize.210;
  unsigned int D.32194;
  sizetype D.32195;
  int D.32196;
  long unsigned int D.32201;
  unsigned char D.32202;
  int D.32203;
  unsigned char D.32204;
  int D.32205;
  struct MonoRuntimeCallbacks * D.32206;
  void (*<T2829>) (struct MonoClass *, struct MonoClass *) D.32207;
  struct MonoException * D.32208;
  struct MonoException * D.32209;
  struct MonoRuntimeCallbacks * D.32210;
  void (*<T2829>) (struct MonoClass *, struct MonoClass *) D.32211;
  struct MonoException * D.32212;
  long unsigned int D.32214;
  long unsigned int D.32215;
  struct MonoObject * D.32218;
  struct MonoRuntimeCallbacks * D.32221;
  void (*<T2829>) (struct MonoClass *, struct MonoClass *) D.32222;
  struct MonoException * D.32223;
  struct MonoObject * D.32224;
  long unsigned int D.32227;
  void * D.32230;
  const void * D.32232;
  long unsigned int D.32233;
  long unsigned int D.32234;
  struct MonoRuntimeCallbacks * D.32237;
  void (*<T2829>) (struct MonoClass *, struct MonoClass *) D.32238;
  struct MonoException * D.32239;
  int D.32240;
  unsigned int D.32241;
  unsigned int D.32242;
  struct MonoClass * D.32245;
  long unsigned int D.32246;
  long unsigned int D.32247;
  struct MonoType * D.32250;
  unsigned char D.32251;
  struct MonoClass * D.32254;
  long unsigned int D.32255;
  long unsigned int D.32256;
  struct MonoType * D.32259;
  unsigned char D.32260;
  unsigned char D.32261;
  short unsigned int D.32262;
  unsigned int D.32263;
  signed char D.32264;
  short int D.32265;
  int D.32266;
  float D.32267;
  struct MonoException * D.32268;
  struct MonoRuntimeCallbacks * D.32269;
  void (*<T2829>) (struct MonoClass *, struct MonoClass *) D.32270;
  struct MonoException * D.32271;
  struct MonoException * D.32275;
  short unsigned int D.32276;
  struct MonoException * D.32277;
  struct MonoException * D.32281;
  unsigned char D.32282;
  struct MonoException * D.32283;
  struct MonoException * D.32287;
  struct MonoException * D.32288;
  struct MonoException * D.32292;
  unsigned int D.32293;
  struct MonoException * D.32294;
  struct MonoException * D.32298;
  struct MonoException * D.32299;
  struct MonoException * D.32303;
  signed char D.32304;
  struct MonoException * D.32307;
  signed char D.32308;
  struct MonoException * D.32309;
  struct MonoException * D.32313;
  short int D.32314;
  struct MonoException * D.32317;
  short int D.32318;
  struct MonoException * D.32319;
  struct MonoException * D.32323;
  int D.32324;
  struct MonoException * D.32327;
  int D.32328;
  struct MonoException * D.32329;
  struct MonoException * D.32333;
  struct MonoException * D.32336;
  long int u64.211;
  struct MonoException * D.32338;
  struct MonoException * D.32342;
  float D.32343;
  float D.32344;
  float D.32345;
  struct MonoException * D.32349;
  double D.32350;
  double D.32351;
  struct MonoRuntimeCallbacks * D.32354;
  void (*<T2829>) (struct MonoClass *, struct MonoClass *) D.32355;
  struct MonoException * D.32356;
  struct MonoClass * ac;
  struct MonoClass * vc;
  struct MonoClass * ec;
  gint32 esize;
  gint32 vsize;
  void * * ea;
  void * * va;
  int et;
  int vt;
  guint64 u64;
  gint64 i64;
  gdouble r64;

  u64 = 0;
  i64 = 0;
  r64 = 0.0;
  if (value != 0B) goto <D.32187>; else goto <D.32188>;
  <D.32187>:
  D.32189 = value->vtable;
  vc = D.32189->klass;
  goto <D.32190>;
  <D.32188>:
  vc = 0B;
  <D.32190>:
  D.32191 = this->obj.vtable;
  ac = D.32191->klass;
  ec = ac->element_class;
  esize = mono_array_element_size (ac);
  D.32192 = &this->vector;
  esize.210 = (unsigned int) esize;
  D.32194 = pos * esize.210;
  D.32195 = (sizetype) D.32194;
  ea = D.32192 + D.32195;
  va = value + 16;
  D.32196 = mono_class_is_nullable (ec);
  if (D.32196 != 0) goto <D.32197>; else goto <D.32198>;
  <D.32197>:
  mono_nullable_init (ea, value, ec);
  return;
  <D.32198>:
  if (value == 0B) goto <D.32199>; else goto <D.32200>;
  <D.32199>:
  D.32201 = (long unsigned int) esize;
  mono_gc_bzero_atomic (ea, D.32201);
  return;
  <D.32200>:
  D.32202 = ec->byval_arg.type;
  D.32203 = (int) D.32202;
  switch (D.32203) <default: <D.32213>, case 2: <D.21271>, case 14: <D.21266>>
  <D.21266>:
  D.32204 = vc->byval_arg.type;
  D.32205 = (int) D.32204;
  switch (D.32205) <default: <D.21269>, case 14: <D.21267>>
  <D.21267>:
  goto <D.21268>;
  <D.21269>:
  D.32206 = mono_get_runtime_callbacks ();
  D.32207 = D.32206->set_cast_details;
  D.32207 (vc, ec);
  D.32208 = mono_get_exception_invalid_cast ();
  mono_raise_exception (D.32208);
  <D.21268>:
  goto <D.21270>;
  <D.21271>:
  D.32204 = vc->byval_arg.type;
  D.32205 = (int) D.32204;
  switch (D.32205) <default: <D.21285>, case 2: <D.21272>, case 3: <D.21274>, case 4: <D.21279>, case 5: <D.21275>, case 6: <D.21280>, case 7: <D.21276>, case 8: <D.21281>, case 9: <D.21277>, case 10: <D.21282>, case 11: <D.21278>, case 12: <D.21283>, case 13: <D.21284>>
  <D.21272>:
  goto <D.21273>;
  <D.21274>:
  <D.21275>:
  <D.21276>:
  <D.21277>:
  <D.21278>:
  <D.21279>:
  <D.21280>:
  <D.21281>:
  <D.21282>:
  <D.21283>:
  <D.21284>:
  D.32209 = mono_get_exception_argument ("value", "not a widening conversion");
  mono_raise_exception (D.32209);
  <D.21285>:
  D.32210 = mono_get_runtime_callbacks ();
  D.32211 = D.32210->set_cast_details;
  D.32211 (vc, ec);
  D.32212 = mono_get_exception_invalid_cast ();
  mono_raise_exception (D.32212);
  <D.21273>:
  goto <D.21270>;
  <D.32213>:
  <D.21270>:
  D.32214 = BIT_FIELD_REF <*ec, 64, 256>;
  D.32215 = D.32214 & 8;
  if (D.32215 == 0) goto <D.32216>; else goto <D.32217>;
  <D.32216>:
  D.32218 = mono_object_isinst (value, ec);
  if (D.32218 == 0B) goto <D.32219>; else goto <D.32220>;
  <D.32219>:
  D.32221 = mono_get_runtime_callbacks ();
  D.32222 = D.32221->set_cast_details;
  D.32222 (vc, ec);
  D.32223 = mono_get_exception_invalid_cast ();
  mono_raise_exception (D.32223);
  <D.32220>:
  mono_gc_wbarrier_set_arrayref (this, ea, value);
  return;
  <D.32217>:
  D.32224 = mono_object_isinst (value, ec);
  if (D.32224 != 0B) goto <D.32225>; else goto <D.32226>;
  <D.32225>:
  D.32214 = BIT_FIELD_REF <*ec, 64, 256>;
  D.32227 = D.32214 & 134217728;
  if (D.32227 != 0) goto <D.32228>; else goto <D.32229>;
  <D.32228>:
  D.32230 = value + 16;
  mono_value_copy (ea, D.32230, ec);
  goto <D.32231>;
  <D.32229>:
  D.32232 = value + 16;
  D.32201 = (long unsigned int) esize;
  mono_gc_memmove_atomic (ea, D.32232, D.32201);
  <D.32231>:
  return;
  <D.32226>:
  D.32233 = BIT_FIELD_REF <*vc, 64, 256>;
  D.32234 = D.32233 & 8;
  if (D.32234 == 0) goto <D.32235>; else goto <D.32236>;
  <D.32235>:
  D.32237 = mono_get_runtime_callbacks ();
  D.32238 = D.32237->set_cast_details;
  D.32238 (vc, ec);
  D.32239 = mono_get_exception_invalid_cast ();
  mono_raise_exception (D.32239);
  <D.32236>:
  D.32240 = mono_class_instance_size (vc);
  D.32241 = (unsigned int) D.32240;
  D.32242 = D.32241 + 4294967280;
  vsize = (gint32) D.32242;
  D.32202 = ec->byval_arg.type;
  et = (int) D.32202;
  if (et == 17) goto <D.32243>; else goto <D.32244>;
  <D.32243>:
  D.32245 = ec->byval_arg.data.klass;
  D.32246 = BIT_FIELD_REF <*D.32245, 64, 256>;
  D.32247 = D.32246 & 16;
  if (D.32247 != 0) goto <D.32248>; else goto <D.32249>;
  <D.32248>:
  D.32245 = ec->byval_arg.data.klass;
  D.32250 = mono_class_enum_basetype (D.32245);
  D.32251 = D.32250->type;
  et = (int) D.32251;
  <D.32249>:
  <D.32244>:
  D.32204 = vc->byval_arg.type;
  vt = (int) D.32204;
  if (vt == 17) goto <D.32252>; else goto <D.32253>;
  <D.32252>:
  D.32254 = vc->byval_arg.data.klass;
  D.32255 = BIT_FIELD_REF <*D.32254, 64, 256>;
  D.32256 = D.32255 & 16;
  if (D.32256 != 0) goto <D.32257>; else goto <D.32258>;
  <D.32257>:
  D.32254 = vc->byval_arg.data.klass;
  D.32259 = mono_class_enum_basetype (D.32254);
  D.32260 = D.32259->type;
  vt = (int) D.32260;
  <D.32258>:
  <D.32253>:
  switch (vt) <default: <D.32272>, case 2: <D.21298>, case 3: <D.21297>, case 4: <D.21291>, case 5: <D.21286>, case 6: <D.21292>, case 7: <D.21288>, case 8: <D.21293>, case 9: <D.21289>, case 10: <D.21294>, case 11: <D.21290>, case 12: <D.21295>, case 13: <D.21296>>
  <D.21286>:
  D.32261 = MEM[(guint8 *)va];
  u64 = (guint64) D.32261;
  goto <D.21287>;
  <D.21288>:
  D.32262 = MEM[(guint16 *)va];
  u64 = (guint64) D.32262;
  goto <D.21287>;
  <D.21289>:
  D.32263 = MEM[(guint32 *)va];
  u64 = (guint64) D.32263;
  goto <D.21287>;
  <D.21290>:
  u64 = MEM[(guint64 *)va];
  goto <D.21287>;
  <D.21291>:
  D.32264 = MEM[(gint8 *)va];
  i64 = (gint64) D.32264;
  goto <D.21287>;
  <D.21292>:
  D.32265 = MEM[(gint16 *)va];
  i64 = (gint64) D.32265;
  goto <D.21287>;
  <D.21293>:
  D.32266 = MEM[(gint32 *)va];
  i64 = (gint64) D.32266;
  goto <D.21287>;
  <D.21294>:
  i64 = MEM[(gint64 *)va];
  goto <D.21287>;
  <D.21295>:
  D.32267 = MEM[(gfloat *)va];
  r64 = (gdouble) D.32267;
  goto <D.21287>;
  <D.21296>:
  r64 = MEM[(gdouble *)va];
  goto <D.21287>;
  <D.21297>:
  D.32262 = MEM[(guint16 *)va];
  u64 = (guint64) D.32262;
  goto <D.21287>;
  <D.21298>:
  switch (et) <default: <D.21310>, case 3: <D.21299>, case 4: <D.21304>, case 5: <D.21300>, case 6: <D.21305>, case 7: <D.21301>, case 8: <D.21306>, case 9: <D.21302>, case 10: <D.21307>, case 11: <D.21303>, case 12: <D.21308>, case 13: <D.21309>>
  <D.21299>:
  <D.21300>:
  <D.21301>:
  <D.21302>:
  <D.21303>:
  <D.21304>:
  <D.21305>:
  <D.21306>:
  <D.21307>:
  <D.21308>:
  <D.21309>:
  D.32268 = mono_get_exception_argument ("value", "not a widening conversion");
  mono_raise_exception (D.32268);
  <D.21310>:
  D.32269 = mono_get_runtime_callbacks ();
  D.32270 = D.32269->set_cast_details;
  D.32270 (vc, ec);
  D.32271 = mono_get_exception_invalid_cast ();
  mono_raise_exception (D.32271);
  goto <D.21287>;
  <D.32272>:
  <D.21287>:
  switch (et) <default: <D.32353>, case 3: <D.21311>, case 4: <D.21371>, case 5: <D.21323>, case 6: <D.21383>, case 7: <D.21335>, case 8: <D.21395>, case 9: <D.21347>, case 10: <D.21407>, case 11: <D.21359>, case 12: <D.21419>, case 13: <D.21431>>
  <D.21311>:
  switch (vt) <default: <D.32278>, case 3: <D.21316>, case 4: <D.21317>, case 5: <D.21312>, case 6: <D.21318>, case 7: <D.21313>, case 8: <D.21319>, case 9: <D.21314>, case 10: <D.21320>, case 11: <D.21315>, case 12: <D.21321>, case 13: <D.21322>>
  <D.21312>:
  <D.21313>:
  <D.21314>:
  <D.21315>:
  <D.21316>:
  if (esize < vsize) goto <D.32273>; else goto <D.32274>;
  <D.32273>:
  D.32275 = mono_get_exception_argument ("value", "not a widening conversion");
  mono_raise_exception (D.32275);
  <D.32274>:
  D.32276 = (short unsigned int) u64;
  MEM[(guint16 *)ea] = D.32276;
  return;
  <D.21317>:
  <D.21318>:
  <D.21319>:
  <D.21320>:
  <D.21321>:
  <D.21322>:
  D.32277 = mono_get_exception_argument ("value", "not a widening conversion");
  mono_raise_exception (D.32277);
  <D.32278>:
  <D.21323>:
  switch (vt) <default: <D.32284>, case 3: <D.21328>, case 4: <D.21329>, case 5: <D.21324>, case 6: <D.21330>, case 7: <D.21325>, case 8: <D.21331>, case 9: <D.21326>, case 10: <D.21332>, case 11: <D.21327>, case 12: <D.21333>, case 13: <D.21334>>
  <D.21324>:
  <D.21325>:
  <D.21326>:
  <D.21327>:
  <D.21328>:
  if (esize < vsize) goto <D.32279>; else goto <D.32280>;
  <D.32279>:
  D.32281 = mono_get_exception_argument ("value", "not a widening conversion");
  mono_raise_exception (D.32281);
  <D.32280>:
  D.32282 = (unsigned char) u64;
  MEM[(guint8 *)ea] = D.32282;
  return;
  <D.21329>:
  <D.21330>:
  <D.21331>:
  <D.21332>:
  <D.21333>:
  <D.21334>:
  D.32283 = mono_get_exception_argument ("value", "not a widening conversion");
  mono_raise_exception (D.32283);
  <D.32284>:
  <D.21335>:
  switch (vt) <default: <D.32289>, case 3: <D.21340>, case 4: <D.21341>, case 5: <D.21336>, case 6: <D.21342>, case 7: <D.21337>, case 8: <D.21343>, case 9: <D.21338>, case 10: <D.21344>, case 11: <D.21339>, case 12: <D.21345>, case 13: <D.21346>>
  <D.21336>:
  <D.21337>:
  <D.21338>:
  <D.21339>:
  <D.21340>:
  if (esize < vsize) goto <D.32285>; else goto <D.32286>;
  <D.32285>:
  D.32287 = mono_get_exception_argument ("value", "not a widening conversion");
  mono_raise_exception (D.32287);
  <D.32286>:
  D.32276 = (short unsigned int) u64;
  MEM[(guint16 *)ea] = D.32276;
  return;
  <D.21341>:
  <D.21342>:
  <D.21343>:
  <D.21344>:
  <D.21345>:
  <D.21346>:
  D.32288 = mono_get_exception_argument ("value", "not a widening conversion");
  mono_raise_exception (D.32288);
  <D.32289>:
  <D.21347>:
  switch (vt) <default: <D.32295>, case 3: <D.21352>, case 4: <D.21353>, case 5: <D.21348>, case 6: <D.21354>, case 7: <D.21349>, case 8: <D.21355>, case 9: <D.21350>, case 10: <D.21356>, case 11: <D.21351>, case 12: <D.21357>, case 13: <D.21358>>
  <D.21348>:
  <D.21349>:
  <D.21350>:
  <D.21351>:
  <D.21352>:
  if (esize < vsize) goto <D.32290>; else goto <D.32291>;
  <D.32290>:
  D.32292 = mono_get_exception_argument ("value", "not a widening conversion");
  mono_raise_exception (D.32292);
  <D.32291>:
  D.32293 = (unsigned int) u64;
  MEM[(guint32 *)ea] = D.32293;
  return;
  <D.21353>:
  <D.21354>:
  <D.21355>:
  <D.21356>:
  <D.21357>:
  <D.21358>:
  D.32294 = mono_get_exception_argument ("value", "not a widening conversion");
  mono_raise_exception (D.32294);
  <D.32295>:
  <D.21359>:
  switch (vt) <default: <D.32300>, case 3: <D.21364>, case 4: <D.21365>, case 5: <D.21360>, case 6: <D.21366>, case 7: <D.21361>, case 8: <D.21367>, case 9: <D.21362>, case 10: <D.21368>, case 11: <D.21363>, case 12: <D.21369>, case 13: <D.21370>>
  <D.21360>:
  <D.21361>:
  <D.21362>:
  <D.21363>:
  <D.21364>:
  if (esize < vsize) goto <D.32296>; else goto <D.32297>;
  <D.32296>:
  D.32298 = mono_get_exception_argument ("value", "not a widening conversion");
  mono_raise_exception (D.32298);
  <D.32297>:
  MEM[(guint64 *)ea] = u64;
  return;
  <D.21365>:
  <D.21366>:
  <D.21367>:
  <D.21368>:
  <D.21369>:
  <D.21370>:
  D.32299 = mono_get_exception_argument ("value", "not a widening conversion");
  mono_raise_exception (D.32299);
  <D.32300>:
  <D.21371>:
  switch (vt) <default: <D.32310>, case 3: <D.21380>, case 4: <D.21372>, case 5: <D.21376>, case 6: <D.21373>, case 7: <D.21377>, case 8: <D.21374>, case 9: <D.21378>, case 10: <D.21375>, case 11: <D.21379>, case 12: <D.21381>, case 13: <D.21382>>
  <D.21372>:
  <D.21373>:
  <D.21374>:
  <D.21375>:
  if (esize < vsize) goto <D.32301>; else goto <D.32302>;
  <D.32301>:
  D.32303 = mono_get_exception_argument ("value", "not a widening conversion");
  mono_raise_exception (D.32303);
  <D.32302>:
  D.32304 = (signed char) i64;
  MEM[(gint8 *)ea] = D.32304;
  return;
  <D.21376>:
  <D.21377>:
  <D.21378>:
  <D.21379>:
  <D.21380>:
  if (vsize >= esize) goto <D.32305>; else goto <D.32306>;
  <D.32305>:
  D.32307 = mono_get_exception_argument ("value", "not a widening conversion");
  mono_raise_exception (D.32307);
  <D.32306>:
  D.32308 = (signed char) u64;
  MEM[(gint8 *)ea] = D.32308;
  return;
  <D.21381>:
  <D.21382>:
  D.32309 = mono_get_exception_argument ("value", "not a widening conversion");
  mono_raise_exception (D.32309);
  <D.32310>:
  <D.21383>:
  switch (vt) <default: <D.32320>, case 3: <D.21392>, case 4: <D.21384>, case 5: <D.21388>, case 6: <D.21385>, case 7: <D.21389>, case 8: <D.21386>, case 9: <D.21390>, case 10: <D.21387>, case 11: <D.21391>, case 12: <D.21393>, case 13: <D.21394>>
  <D.21384>:
  <D.21385>:
  <D.21386>:
  <D.21387>:
  if (esize < vsize) goto <D.32311>; else goto <D.32312>;
  <D.32311>:
  D.32313 = mono_get_exception_argument ("value", "not a widening conversion");
  mono_raise_exception (D.32313);
  <D.32312>:
  D.32314 = (short int) i64;
  MEM[(gint16 *)ea] = D.32314;
  return;
  <D.21388>:
  <D.21389>:
  <D.21390>:
  <D.21391>:
  <D.21392>:
  if (vsize >= esize) goto <D.32315>; else goto <D.32316>;
  <D.32315>:
  D.32317 = mono_get_exception_argument ("value", "not a widening conversion");
  mono_raise_exception (D.32317);
  <D.32316>:
  D.32318 = (short int) u64;
  MEM[(gint16 *)ea] = D.32318;
  return;
  <D.21393>:
  <D.21394>:
  D.32319 = mono_get_exception_argument ("value", "not a widening conversion");
  mono_raise_exception (D.32319);
  <D.32320>:
  <D.21395>:
  switch (vt) <default: <D.32330>, case 3: <D.21404>, case 4: <D.21396>, case 5: <D.21400>, case 6: <D.21397>, case 7: <D.21401>, case 8: <D.21398>, case 9: <D.21402>, case 10: <D.21399>, case 11: <D.21403>, case 12: <D.21405>, case 13: <D.21406>>
  <D.21396>:
  <D.21397>:
  <D.21398>:
  <D.21399>:
  if (esize < vsize) goto <D.32321>; else goto <D.32322>;
  <D.32321>:
  D.32323 = mono_get_exception_argument ("value", "not a widening conversion");
  mono_raise_exception (D.32323);
  <D.32322>:
  D.32324 = (int) i64;
  MEM[(gint32 *)ea] = D.32324;
  return;
  <D.21400>:
  <D.21401>:
  <D.21402>:
  <D.21403>:
  <D.21404>:
  if (vsize >= esize) goto <D.32325>; else goto <D.32326>;
  <D.32325>:
  D.32327 = mono_get_exception_argument ("value", "not a widening conversion");
  mono_raise_exception (D.32327);
  <D.32326>:
  D.32328 = (int) u64;
  MEM[(gint32 *)ea] = D.32328;
  return;
  <D.21405>:
  <D.21406>:
  D.32329 = mono_get_exception_argument ("value", "not a widening conversion");
  mono_raise_exception (D.32329);
  <D.32330>:
  <D.21407>:
  switch (vt) <default: <D.32339>, case 3: <D.21416>, case 4: <D.21408>, case 5: <D.21412>, case 6: <D.21409>, case 7: <D.21413>, case 8: <D.21410>, case 9: <D.21414>, case 10: <D.21411>, case 11: <D.21415>, case 12: <D.21417>, case 13: <D.21418>>
  <D.21408>:
  <D.21409>:
  <D.21410>:
  <D.21411>:
  if (esize < vsize) goto <D.32331>; else goto <D.32332>;
  <D.32331>:
  D.32333 = mono_get_exception_argument ("value", "not a widening conversion");
  mono_raise_exception (D.32333);
  <D.32332>:
  MEM[(gint64 *)ea] = i64;
  return;
  <D.21412>:
  <D.21413>:
  <D.21414>:
  <D.21415>:
  <D.21416>:
  if (vsize >= esize) goto <D.32334>; else goto <D.32335>;
  <D.32334>:
  D.32336 = mono_get_exception_argument ("value", "not a widening conversion");
  mono_raise_exception (D.32336);
  <D.32335>:
  u64.211 = (long int) u64;
  MEM[(gint64 *)ea] = u64.211;
  return;
  <D.21417>:
  <D.21418>:
  D.32338 = mono_get_exception_argument ("value", "not a widening conversion");
  mono_raise_exception (D.32338);
  <D.32339>:
  <D.21419>:
  switch (vt) <default: <D.32346>, case 3: <D.21430>, case 4: <D.21422>, case 5: <D.21426>, case 6: <D.21423>, case 7: <D.21427>, case 8: <D.21424>, case 9: <D.21428>, case 10: <D.21425>, case 11: <D.21429>, case 12: <D.21420>, case 13: <D.21421>>
  <D.21420>:
  <D.21421>:
  if (esize < vsize) goto <D.32340>; else goto <D.32341>;
  <D.32340>:
  D.32342 = mono_get_exception_argument ("value", "not a widening conversion");
  mono_raise_exception (D.32342);
  <D.32341>:
  D.32343 = (float) r64;
  MEM[(gfloat *)ea] = D.32343;
  return;
  <D.21422>:
  <D.21423>:
  <D.21424>:
  <D.21425>:
  D.32344 = (float) i64;
  MEM[(gfloat *)ea] = D.32344;
  return;
  <D.21426>:
  <D.21427>:
  <D.21428>:
  <D.21429>:
  <D.21430>:
  D.32345 = (float) u64;
  MEM[(gfloat *)ea] = D.32345;
  return;
  <D.32346>:
  <D.21431>:
  switch (vt) <default: <D.32352>, case 3: <D.21442>, case 4: <D.21434>, case 5: <D.21438>, case 6: <D.21435>, case 7: <D.21439>, case 8: <D.21436>, case 9: <D.21440>, case 10: <D.21437>, case 11: <D.21441>, case 12: <D.21432>, case 13: <D.21433>>
  <D.21432>:
  <D.21433>:
  if (esize < vsize) goto <D.32347>; else goto <D.32348>;
  <D.32347>:
  D.32349 = mono_get_exception_argument ("value", "not a widening conversion");
  mono_raise_exception (D.32349);
  <D.32348>:
  MEM[(gdouble *)ea] = r64;
  return;
  <D.21434>:
  <D.21435>:
  <D.21436>:
  <D.21437>:
  D.32350 = (double) i64;
  MEM[(gdouble *)ea] = D.32350;
  return;
  <D.21438>:
  <D.21439>:
  <D.21440>:
  <D.21441>:
  <D.21442>:
  D.32351 = (double) u64;
  MEM[(gdouble *)ea] = D.32351;
  return;
  <D.32352>:
  <D.32353>:
  D.32354 = mono_get_runtime_callbacks ();
  D.32355 = D.32354->set_cast_details;
  D.32355 (vc, ec);
  D.32356 = mono_get_exception_invalid_cast ();
  mono_raise_exception (D.32356);
  return;
}


ves_icall_System_Array_SetValue (struct MonoArray * this, struct MonoObject * value, struct MonoArray * idxs)
{
  _Bool D.32360;
  long int D.32361;
  long int D.32362;
  struct MonoVTable * D.32367;
  struct MonoVTable * D.32368;
  unsigned char D.32369;
  _Bool D.32370;
  long int D.32371;
  long int D.32372;
  struct MonoArrayBounds * D.32377;
  unsigned int D.32379;
  unsigned char D.32380;
  unsigned int D.32381;
  struct MonoException * D.32382;
  struct MonoArrayBounds * D.32383;
  int D.32388;
  unsigned int D.32390;
  unsigned int D.32391;
  struct MonoException * D.32392;
  unsigned int D.32393;
  long unsigned int D.32396;
  long unsigned int D.32397;
  gint32 * D.32398;
  int D.32399;
  long unsigned int D.32400;
  struct MonoArrayBounds * D.32401;
  int D.32402;
  unsigned int D.32404;
  int D.32405;
  int D.32406;
  struct MonoException * D.32407;
  int D.32408;
  int D.32409;
  unsigned int pos.212;
  unsigned int D.32411;
  unsigned int D.32412;
  unsigned int D.32413;
  unsigned int D.32414;
  unsigned int D.32415;
  unsigned int pos.213;
  struct MonoClass * ac;
  struct MonoClass * ic;
  gint32 i;
  gint32 pos;
  gint32 * ind;

  D.32360 = idxs == 0B;
  D.32361 = (long int) D.32360;
  D.32362 = __builtin_expect (D.32361, 0);
  if (D.32362 != 0) goto <D.32363>; else goto <D.32364>;
  <D.32363>:
  {
    struct MonoException * ex;

    if (idxs != 0B) goto <D.32365>; else goto <D.32366>;
    <D.32365>:
    <D.32366>:
    ex = mono_get_exception_argument_null ("idxs");
    mono_raise_exception (ex);
  }
  <D.32364>:
  D.32367 = idxs->obj.vtable;
  ic = D.32367->klass;
  D.32368 = this->obj.vtable;
  ac = D.32368->klass;
  D.32369 = ic->rank;
  D.32370 = D.32369 != 1;
  D.32371 = (long int) D.32370;
  D.32372 = __builtin_expect (D.32371, 0);
  if (D.32372 != 0) goto <D.32373>; else goto <D.32374>;
  <D.32373>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "icall.c", 502, "ic->rank == 1");
  <D.32374>:
  D.32377 = idxs->bounds;
  if (D.32377 != 0B) goto <D.32375>; else goto <D.32378>;
  <D.32378>:
  D.32379 = idxs->max_length;
  D.32380 = ac->rank;
  D.32381 = (unsigned int) D.32380;
  if (D.32379 != D.32381) goto <D.32375>; else goto <D.32376>;
  <D.32375>:
  D.32382 = mono_get_exception_argument (0B, 0B);
  mono_raise_exception (D.32382);
  <D.32376>:
  ind = &idxs->vector;
  D.32383 = this->bounds;
  if (D.32383 == 0B) goto <D.32384>; else goto <D.32385>;
  <D.32384>:
  D.32388 = *ind;
  if (D.32388 < 0) goto <D.32386>; else goto <D.32389>;
  <D.32389>:
  D.32388 = *ind;
  D.32390 = (unsigned int) D.32388;
  D.32391 = this->max_length;
  if (D.32390 >= D.32391) goto <D.32386>; else goto <D.32387>;
  <D.32386>:
  D.32392 = mono_get_exception_index_out_of_range ();
  mono_raise_exception (D.32392);
  <D.32387>:
  D.32388 = *ind;
  D.32393 = (unsigned int) D.32388;
  ves_icall_System_Array_SetValueImpl (this, value, D.32393);
  return;
  <D.32385>:
  i = 0;
  goto <D.21455>;
  <D.21454>:
  D.32396 = (long unsigned int) i;
  D.32397 = D.32396 * 4;
  D.32398 = ind + D.32397;
  D.32399 = *D.32398;
  D.32383 = this->bounds;
  D.32396 = (long unsigned int) i;
  D.32400 = D.32396 * 8;
  D.32401 = D.32383 + D.32400;
  D.32402 = D.32401->lower_bound;
  if (D.32399 < D.32402) goto <D.32394>; else goto <D.32403>;
  <D.32403>:
  D.32396 = (long unsigned int) i;
  D.32397 = D.32396 * 4;
  D.32398 = ind + D.32397;
  D.32399 = *D.32398;
  D.32383 = this->bounds;
  D.32396 = (long unsigned int) i;
  D.32400 = D.32396 * 8;
  D.32401 = D.32383 + D.32400;
  D.32404 = D.32401->length;
  D.32405 = (int) D.32404;
  D.32383 = this->bounds;
  D.32396 = (long unsigned int) i;
  D.32400 = D.32396 * 8;
  D.32401 = D.32383 + D.32400;
  D.32402 = D.32401->lower_bound;
  D.32406 = D.32405 + D.32402;
  if (D.32399 >= D.32406) goto <D.32394>; else goto <D.32395>;
  <D.32394>:
  D.32407 = mono_get_exception_index_out_of_range ();
  mono_raise_exception (D.32407);
  <D.32395>:
  i = i + 1;
  <D.21455>:
  D.32380 = ac->rank;
  D.32408 = (int) D.32380;
  if (D.32408 > i) goto <D.21454>; else goto <D.21456>;
  <D.21456>:
  D.32388 = *ind;
  D.32383 = this->bounds;
  D.32409 = D.32383->lower_bound;
  pos = D.32388 - D.32409;
  i = 1;
  goto <D.21458>;
  <D.21457>:
  D.32383 = this->bounds;
  D.32396 = (long unsigned int) i;
  D.32400 = D.32396 * 8;
  D.32401 = D.32383 + D.32400;
  D.32404 = D.32401->length;
  pos.212 = (unsigned int) pos;
  D.32411 = D.32404 * pos.212;
  D.32396 = (long unsigned int) i;
  D.32397 = D.32396 * 4;
  D.32398 = ind + D.32397;
  D.32399 = *D.32398;
  D.32412 = (unsigned int) D.32399;
  D.32413 = D.32411 + D.32412;
  D.32383 = this->bounds;
  D.32396 = (long unsigned int) i;
  D.32400 = D.32396 * 8;
  D.32401 = D.32383 + D.32400;
  D.32402 = D.32401->lower_bound;
  D.32414 = (unsigned int) D.32402;
  D.32415 = D.32413 - D.32414;
  pos = (gint32) D.32415;
  i = i + 1;
  <D.21458>:
  D.32380 = ac->rank;
  D.32408 = (int) D.32380;
  if (D.32408 > i) goto <D.21457>; else goto <D.21459>;
  <D.21459>:
  pos.213 = (unsigned int) pos;
  ves_icall_System_Array_SetValueImpl (this, value, pos.213);
}


ves_icall_System_Array_SetGenericValueImpl (struct MonoObject * this, guint32 pos, void * value)
{
  struct MonoVTable * D.32418;
  double[0:] * D.32419;
  unsigned int esize.214;
  unsigned int D.32421;
  sizetype D.32422;
  struct MonoType * D.32423;
  int D.32424;
  _Bool D.32427;
  long int D.32428;
  long int D.32429;
  void * D.32432;
  long unsigned int D.32434;
  long unsigned int D.32435;
  _Bool D.32436;
  long int D.32437;
  long int D.32438;
  int D.32441;
  _Bool D.32442;
  long int D.32443;
  long int D.32444;
  long unsigned int D.32447;
  long unsigned int D.32451;
  struct MonoClass * ac;
  struct MonoClass * ec;
  struct MonoArray * ao;
  gint32 esize;
  void * * ea;

  ao = this;
  D.32418 = ao->obj.vtable;
  ac = D.32418->klass;
  ec = ac->element_class;
  esize = mono_array_element_size (ac);
  D.32419 = &ao->vector;
  esize.214 = (unsigned int) esize;
  D.32421 = pos * esize.214;
  D.32422 = (sizetype) D.32421;
  ea = D.32419 + D.32422;
  D.32423 = &ec->byval_arg;
  D.32424 = mono_type_is_reference (D.32423);
  if (D.32424 != 0) goto <D.32425>; else goto <D.32426>;
  <D.32425>:
  D.32427 = esize != 8;
  D.32428 = (long int) D.32427;
  D.32429 = __builtin_expect (D.32428, 0);
  if (D.32429 != 0) goto <D.32430>; else goto <D.32431>;
  <D.32430>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "icall.c", 793, "esize == sizeof (gpointer)");
  <D.32431>:
  D.32432 = MEM[(void * *)value];
  mono_gc_wbarrier_generic_store (ea, D.32432);
  goto <D.32433>;
  <D.32426>:
  D.32434 = BIT_FIELD_REF <*ec, 64, 256>;
  D.32435 = D.32434 & 1;
  D.32436 = D.32435 == 0;
  D.32437 = (long int) D.32436;
  D.32438 = __builtin_expect (D.32437, 0);
  if (D.32438 != 0) goto <D.32439>; else goto <D.32440>;
  <D.32439>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "icall.c", 796, "ec->inited");
  <D.32440>:
  D.32441 = mono_class_value_size (ec, 0B);
  D.32442 = D.32441 != esize;
  D.32443 = (long int) D.32442;
  D.32444 = __builtin_expect (D.32443, 0);
  if (D.32444 != 0) goto <D.32445>; else goto <D.32446>;
  <D.32445>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "icall.c", 797, "esize == mono_class_value_size (ec, NULL)");
  <D.32446>:
  D.32434 = BIT_FIELD_REF <*ec, 64, 256>;
  D.32447 = D.32434 & 134217728;
  if (D.32447 != 0) goto <D.32448>; else goto <D.32449>;
  <D.32448>:
  mono_gc_wbarrier_value_copy (ea, value, 1, ec);
  goto <D.32450>;
  <D.32449>:
  D.32451 = (long unsigned int) esize;
  mono_gc_memmove_atomic (ea, value, D.32451);
  <D.32450>:
  <D.32433>:
}


ves_icall_System_Array_GetValueImpl (struct MonoObject * this, guint32 pos)
{
  struct MonoVTable * D.32452;
  double[0:] * D.32453;
  unsigned int esize.215;
  unsigned int D.32455;
  sizetype D.32456;
  struct MonoClass * D.32457;
  long unsigned int D.32458;
  long unsigned int D.32459;
  struct MonoObject * D.32462;
  struct MonoVTable * D.32463;
  struct MonoDomain * D.32464;
  struct MonoClass * ac;
  struct MonoArray * ao;
  gint32 esize;
  void * * ea;

  ao = this;
  D.32452 = ao->obj.vtable;
  ac = D.32452->klass;
  esize = mono_array_element_size (ac);
  D.32453 = &ao->vector;
  esize.215 = (unsigned int) esize;
  D.32455 = pos * esize.215;
  D.32456 = (sizetype) D.32455;
  ea = D.32453 + D.32456;
  D.32457 = ac->element_class;
  D.32458 = BIT_FIELD_REF <*D.32457, 64, 256>;
  D.32459 = D.32458 & 8;
  if (D.32459 != 0) goto <D.32460>; else goto <D.32461>;
  <D.32460>:
  D.32463 = this->vtable;
  D.32464 = D.32463->domain;
  D.32457 = ac->element_class;
  D.32462 = mono_value_box (D.32464, D.32457, ea);
  return D.32462;
  <D.32461>:
  D.32462 = *ea;
  return D.32462;
}


ves_icall_System_Array_GetValue (struct MonoObject * this, struct MonoObject * idxs)
{
  _Bool D.32466;
  long int D.32467;
  long int D.32468;
  struct MonoVTable * D.32473;
  struct MonoVTable * D.32474;
  unsigned char D.32475;
  _Bool D.32476;
  long int D.32477;
  long int D.32478;
  struct MonoArrayBounds * D.32483;
  unsigned int D.32485;
  unsigned char D.32486;
  unsigned int D.32487;
  struct MonoException * D.32488;
  struct MonoArrayBounds * D.32489;
  int D.32494;
  unsigned int D.32496;
  unsigned int D.32497;
  struct MonoException * D.32498;
  struct MonoObject * D.32499;
  unsigned int D.32500;
  long unsigned int D.32503;
  long unsigned int D.32504;
  gint32 * D.32505;
  int D.32506;
  long unsigned int D.32507;
  struct MonoArrayBounds * D.32508;
  int D.32509;
  unsigned int D.32511;
  int D.32512;
  int D.32513;
  struct MonoException * D.32514;
  int D.32515;
  int D.32516;
  unsigned int pos.216;
  unsigned int D.32518;
  unsigned int D.32519;
  unsigned int D.32520;
  unsigned int D.32521;
  unsigned int D.32522;
  unsigned int pos.217;
  struct MonoClass * ac;
  struct MonoClass * ic;
  struct MonoArray * ao;
  struct MonoArray * io;
  gint32 i;
  gint32 pos;
  gint32 * ind;

  D.32466 = idxs == 0B;
  D.32467 = (long int) D.32466;
  D.32468 = __builtin_expect (D.32467, 0);
  if (D.32468 != 0) goto <D.32469>; else goto <D.32470>;
  <D.32469>:
  {
    struct MonoException * ex;

    if (idxs != 0B) goto <D.32471>; else goto <D.32472>;
    <D.32471>:
    <D.32472>:
    ex = mono_get_exception_argument_null ("idxs");
    mono_raise_exception (ex);
  }
  <D.32470>:
  io = idxs;
  D.32473 = io->obj.vtable;
  ic = D.32473->klass;
  ao = this;
  D.32474 = ao->obj.vtable;
  ac = D.32474->klass;
  D.32475 = ic->rank;
  D.32476 = D.32475 != 1;
  D.32477 = (long int) D.32476;
  D.32478 = __builtin_expect (D.32477, 0);
  if (D.32478 != 0) goto <D.32479>; else goto <D.32480>;
  <D.32479>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "icall.c", 184, "ic->rank == 1");
  <D.32480>:
  D.32483 = io->bounds;
  if (D.32483 != 0B) goto <D.32481>; else goto <D.32484>;
  <D.32484>:
  D.32485 = io->max_length;
  D.32486 = ac->rank;
  D.32487 = (unsigned int) D.32486;
  if (D.32485 != D.32487) goto <D.32481>; else goto <D.32482>;
  <D.32481>:
  D.32488 = mono_get_exception_argument (0B, 0B);
  mono_raise_exception (D.32488);
  <D.32482>:
  ind = &io->vector;
  D.32489 = ao->bounds;
  if (D.32489 == 0B) goto <D.32490>; else goto <D.32491>;
  <D.32490>:
  D.32494 = *ind;
  if (D.32494 < 0) goto <D.32492>; else goto <D.32495>;
  <D.32495>:
  D.32494 = *ind;
  D.32496 = (unsigned int) D.32494;
  D.32497 = ao->max_length;
  if (D.32496 >= D.32497) goto <D.32492>; else goto <D.32493>;
  <D.32492>:
  D.32498 = mono_get_exception_index_out_of_range ();
  mono_raise_exception (D.32498);
  <D.32493>:
  D.32494 = *ind;
  D.32500 = (unsigned int) D.32494;
  D.32499 = ves_icall_System_Array_GetValueImpl (this, D.32500);
  return D.32499;
  <D.32491>:
  i = 0;
  goto <D.21244>;
  <D.21243>:
  D.32503 = (long unsigned int) i;
  D.32504 = D.32503 * 4;
  D.32505 = ind + D.32504;
  D.32506 = *D.32505;
  D.32489 = ao->bounds;
  D.32503 = (long unsigned int) i;
  D.32507 = D.32503 * 8;
  D.32508 = D.32489 + D.32507;
  D.32509 = D.32508->lower_bound;
  if (D.32506 < D.32509) goto <D.32501>; else goto <D.32510>;
  <D.32510>:
  D.32503 = (long unsigned int) i;
  D.32504 = D.32503 * 4;
  D.32505 = ind + D.32504;
  D.32506 = *D.32505;
  D.32489 = ao->bounds;
  D.32503 = (long unsigned int) i;
  D.32507 = D.32503 * 8;
  D.32508 = D.32489 + D.32507;
  D.32511 = D.32508->length;
  D.32512 = (int) D.32511;
  D.32489 = ao->bounds;
  D.32503 = (long unsigned int) i;
  D.32507 = D.32503 * 8;
  D.32508 = D.32489 + D.32507;
  D.32509 = D.32508->lower_bound;
  D.32513 = D.32512 + D.32509;
  if (D.32506 >= D.32513) goto <D.32501>; else goto <D.32502>;
  <D.32501>:
  D.32514 = mono_get_exception_index_out_of_range ();
  mono_raise_exception (D.32514);
  <D.32502>:
  i = i + 1;
  <D.21244>:
  D.32486 = ac->rank;
  D.32515 = (int) D.32486;
  if (D.32515 > i) goto <D.21243>; else goto <D.21245>;
  <D.21245>:
  D.32494 = *ind;
  D.32489 = ao->bounds;
  D.32516 = D.32489->lower_bound;
  pos = D.32494 - D.32516;
  i = 1;
  goto <D.21247>;
  <D.21246>:
  D.32489 = ao->bounds;
  D.32503 = (long unsigned int) i;
  D.32507 = D.32503 * 8;
  D.32508 = D.32489 + D.32507;
  D.32511 = D.32508->length;
  pos.216 = (unsigned int) pos;
  D.32518 = D.32511 * pos.216;
  D.32503 = (long unsigned int) i;
  D.32504 = D.32503 * 4;
  D.32505 = ind + D.32504;
  D.32506 = *D.32505;
  D.32519 = (unsigned int) D.32506;
  D.32520 = D.32518 + D.32519;
  D.32489 = ao->bounds;
  D.32503 = (long unsigned int) i;
  D.32507 = D.32503 * 8;
  D.32508 = D.32489 + D.32507;
  D.32509 = D.32508->lower_bound;
  D.32521 = (unsigned int) D.32509;
  D.32522 = D.32520 - D.32521;
  pos = (gint32) D.32522;
  i = i + 1;
  <D.21247>:
  D.32486 = ac->rank;
  D.32515 = (int) D.32486;
  if (D.32515 > i) goto <D.21246>; else goto <D.21248>;
  <D.21248>:
  pos.217 = (unsigned int) pos;
  D.32499 = ves_icall_System_Array_GetValueImpl (this, pos.217);
  return D.32499;
}


ves_icall_System_Array_GetRank (struct MonoObject * this)
{
  gint32 D.32525;
  struct MonoVTable * D.32526;
  struct MonoClass * D.32527;
  unsigned char D.32528;

  D.32526 = this->vtable;
  D.32527 = D.32526->klass;
  D.32528 = D.32527->rank;
  D.32525 = (gint32) D.32528;
  return D.32525;
}


ves_icall_System_Array_GetLowerBound (struct MonoArray * this, gint32 dimension)
{
  struct MonoVTable * D.32530;
  struct MonoClass * D.32531;
  unsigned char D.32532;
  struct MonoException * D.32536;
  struct MonoArrayBounds * D.32537;
  gint32 D.32540;
  long unsigned int D.32541;
  long unsigned int D.32542;
  struct MonoArrayBounds * D.32543;
  gint32 rank;

  D.32530 = MEM[(struct MonoObject *)this].vtable;
  D.32531 = D.32530->klass;
  D.32532 = D.32531->rank;
  rank = (gint32) D.32532;
  if (dimension < 0) goto <D.32533>; else goto <D.32535>;
  <D.32535>:
  if (dimension >= rank) goto <D.32533>; else goto <D.32534>;
  <D.32533>:
  D.32536 = mono_get_exception_index_out_of_range ();
  mono_raise_exception (D.32536);
  <D.32534>:
  D.32537 = this->bounds;
  if (D.32537 == 0B) goto <D.32538>; else goto <D.32539>;
  <D.32538>:
  D.32540 = 0;
  return D.32540;
  <D.32539>:
  D.32537 = this->bounds;
  D.32541 = (long unsigned int) dimension;
  D.32542 = D.32541 * 8;
  D.32543 = D.32537 + D.32542;
  D.32540 = D.32543->lower_bound;
  return D.32540;
}


ves_icall_System_Array_GetLongLength (struct MonoArray * this, gint32 dimension)
{
  struct MonoVTable * D.32545;
  struct MonoClass * D.32546;
  unsigned char D.32547;
  struct MonoException * D.32551;
  struct MonoArrayBounds * D.32552;
  gint64 D.32555;
  unsigned int D.32556;
  long unsigned int D.32557;
  long unsigned int D.32558;
  struct MonoArrayBounds * D.32559;
  unsigned int D.32560;
  gint32 rank;

  D.32545 = MEM[(struct MonoObject *)this].vtable;
  D.32546 = D.32545->klass;
  D.32547 = D.32546->rank;
  rank = (gint32) D.32547;
  if (dimension < 0) goto <D.32548>; else goto <D.32550>;
  <D.32550>:
  if (dimension >= rank) goto <D.32548>; else goto <D.32549>;
  <D.32548>:
  D.32551 = mono_get_exception_index_out_of_range ();
  mono_raise_exception (D.32551);
  <D.32549>:
  D.32552 = this->bounds;
  if (D.32552 == 0B) goto <D.32553>; else goto <D.32554>;
  <D.32553>:
  D.32556 = this->max_length;
  D.32555 = (gint64) D.32556;
  return D.32555;
  <D.32554>:
  D.32552 = this->bounds;
  D.32557 = (long unsigned int) dimension;
  D.32558 = D.32557 * 8;
  D.32559 = D.32552 + D.32558;
  D.32560 = D.32559->length;
  D.32555 = (gint64) D.32560;
  return D.32555;
}


ves_icall_System_Array_GetLength (struct MonoArray * this, gint32 dimension)
{
  struct MonoVTable * D.32562;
  struct MonoClass * D.32563;
  unsigned char D.32564;
  struct MonoException * D.32568;
  struct MonoArrayBounds * D.32569;
  unsigned int D.32572;
  long unsigned int D.32574;
  long unsigned int D.32575;
  struct MonoArrayBounds * D.32576;
  unsigned int D.32577;
  gint32 D.32578;
  gint32 rank;
  uintptr_t length;

  D.32562 = MEM[(struct MonoObject *)this].vtable;
  D.32563 = D.32562->klass;
  D.32564 = D.32563->rank;
  rank = (gint32) D.32564;
  if (dimension < 0) goto <D.32565>; else goto <D.32567>;
  <D.32567>:
  if (dimension >= rank) goto <D.32565>; else goto <D.32566>;
  <D.32565>:
  D.32568 = mono_get_exception_index_out_of_range ();
  mono_raise_exception (D.32568);
  <D.32566>:
  D.32569 = this->bounds;
  if (D.32569 == 0B) goto <D.32570>; else goto <D.32571>;
  <D.32570>:
  D.32572 = this->max_length;
  length = (uintptr_t) D.32572;
  goto <D.32573>;
  <D.32571>:
  D.32569 = this->bounds;
  D.32574 = (long unsigned int) dimension;
  D.32575 = D.32574 * 8;
  D.32576 = D.32569 + D.32575;
  D.32577 = D.32576->length;
  length = (uintptr_t) D.32577;
  <D.32573>:
  D.32578 = (gint32) length;
  return D.32578;
}


ves_icall_System_Array_GetGenericValueImpl (struct MonoObject * this, guint32 pos, void * value)
{
  struct MonoVTable * D.32580;
  double[0:] * D.32581;
  unsigned int esize.218;
  unsigned int D.32583;
  sizetype D.32584;
  long unsigned int D.32585;
  struct MonoClass * ac;
  struct MonoArray * ao;
  gint32 esize;
  void * * ea;

  ao = this;
  D.32580 = ao->obj.vtable;
  ac = D.32580->klass;
  esize = mono_array_element_size (ac);
  D.32581 = &ao->vector;
  esize.218 = (unsigned int) esize;
  D.32583 = pos * esize.218;
  D.32584 = (sizetype) D.32583;
  ea = D.32581 + D.32584;
  D.32585 = (long unsigned int) esize;
  mono_gc_memmove_atomic (value, ea, D.32585);
}


ves_icall_System_Array_FastCopy (struct MonoArray * source, int source_idx, struct MonoArray * dest, int dest_idx, int length)
{
  unsigned char D.32586;
  unsigned char D.32587;
  gboolean D.32590;
  struct MonoArrayBounds * D.32593;
  struct MonoArrayBounds * D.32595;
  int D.32598;
  unsigned int D.32599;
  unsigned int D.32600;
  int D.32602;
  unsigned int D.32603;
  unsigned int D.32604;
  struct MonoClass * D.32605;
  struct MonoClass * D.32606;
  struct MonoClass * D.32607;
  long unsigned int D.32610;
  long unsigned int D.32611;
  long unsigned int D.32618;
  long unsigned int D.32620;
  long unsigned int D.32621;
  int D.32622;
  struct MonoVTable * D.32627;
  struct MonoClass * D.32628;
  double[0:] * D.32629;
  int D.32630;
  sizetype D.32631;
  long unsigned int D.32632;
  double[0:] * D.32636;
  int D.32637;
  sizetype D.32638;
  int D.32639;
  long unsigned int D.32640;
  sizetype D.32642;
  sizetype D.32643;
  int element_size;
  void * dest_addr;
  void * source_addr;
  struct MonoVTable * src_vtable;
  struct MonoVTable * dest_vtable;
  struct MonoClass * src_class;
  struct MonoClass * dest_class;

  src_vtable = source->obj.vtable;
  dest_vtable = dest->obj.vtable;
  D.32586 = src_vtable->rank;
  D.32587 = dest_vtable->rank;
  if (D.32586 != D.32587) goto <D.32588>; else goto <D.32589>;
  <D.32588>:
  D.32590 = 0;
  return D.32590;
  <D.32589>:
  D.32593 = source->bounds;
  if (D.32593 != 0B) goto <D.32591>; else goto <D.32594>;
  <D.32594>:
  D.32595 = dest->bounds;
  if (D.32595 != 0B) goto <D.32591>; else goto <D.32592>;
  <D.32591>:
  D.32590 = 0;
  return D.32590;
  <D.32592>:
  D.32598 = dest_idx + length;
  D.32599 = (unsigned int) D.32598;
  D.32600 = dest->max_length;
  if (D.32599 > D.32600) goto <D.32596>; else goto <D.32601>;
  <D.32601>:
  D.32602 = source_idx + length;
  D.32603 = (unsigned int) D.32602;
  D.32604 = source->max_length;
  if (D.32603 > D.32604) goto <D.32596>; else goto <D.32597>;
  <D.32596>:
  D.32590 = 0;
  return D.32590;
  <D.32597>:
  D.32605 = src_vtable->klass;
  src_class = D.32605->element_class;
  D.32606 = dest_vtable->klass;
  dest_class = D.32606->element_class;
  D.32607 = mono_defaults.object_class;
  if (D.32607 == src_class) goto <D.32608>; else goto <D.32609>;
  <D.32608>:
  D.32610 = BIT_FIELD_REF <*dest_class, 64, 256>;
  D.32611 = D.32610 & 8;
  if (D.32611 != 0) goto <D.32612>; else goto <D.32613>;
  <D.32612>:
  D.32590 = 0;
  return D.32590;
  <D.32613>:
  <D.32609>:
  if (src_class != dest_class) goto <D.32614>; else goto <D.32615>;
  <D.32614>:
  D.32610 = BIT_FIELD_REF <*dest_class, 64, 256>;
  D.32618 = D.32610 & 24;
  if (D.32618 != 0) goto <D.32616>; else goto <D.32619>;
  <D.32619>:
  D.32620 = BIT_FIELD_REF <*src_class, 64, 256>;
  D.32621 = D.32620 & 24;
  if (D.32621 != 0) goto <D.32616>; else goto <D.32617>;
  <D.32616>:
  D.32590 = 0;
  return D.32590;
  <D.32617>:
  D.32622 = mono_class_is_subclass_of (src_class, dest_class, 0);
  if (D.32622 == 0) goto <D.32623>; else goto <D.32624>;
  <D.32623>:
  D.32590 = 0;
  return D.32590;
  <D.32624>:
  <D.32615>:
  D.32610 = BIT_FIELD_REF <*dest_class, 64, 256>;
  D.32611 = D.32610 & 8;
  if (D.32611 != 0) goto <D.32625>; else goto <D.32626>;
  <D.32625>:
  D.32627 = source->obj.vtable;
  D.32628 = D.32627->klass;
  element_size = mono_array_element_size (D.32628);
  D.32629 = &source->vector;
  D.32630 = element_size * source_idx;
  D.32631 = (sizetype) D.32630;
  source_addr = D.32629 + D.32631;
  D.32610 = BIT_FIELD_REF <*dest_class, 64, 256>;
  D.32632 = D.32610 & 134217728;
  if (D.32632 != 0) goto <D.32633>; else goto <D.32634>;
  <D.32633>:
  mono_value_copy_array (dest, dest_idx, source_addr, length);
  goto <D.32635>;
  <D.32634>:
  D.32636 = &dest->vector;
  D.32637 = element_size * dest_idx;
  D.32638 = (sizetype) D.32637;
  dest_addr = D.32636 + D.32638;
  D.32639 = element_size * length;
  D.32640 = (long unsigned int) D.32639;
  mono_gc_memmove_atomic (dest_addr, source_addr, D.32640);
  <D.32635>:
  goto <D.32641>;
  <D.32626>:
  {
    void * * __p;
    void * * __s;

    D.32642 = (sizetype) dest_idx;
    __p = &dest->vector[D.32642];
    D.32643 = (sizetype) source_idx;
    __s = &source->vector[D.32643];
    mono_gc_wbarrier_arrayref_copy (__p, __s, length);
  }
  <D.32641>:
  D.32590 = 1;
  return D.32590;
}


ves_icall_System_Array_CreateInstanceImpl64 (struct MonoReflectionType * type, struct MonoArray * lengths, struct MonoArray * bounds)
{
  _Bool D.32645;
  long int D.32646;
  long int D.32647;
  _Bool D.32652;
  long int D.32653;
  long int D.32654;
  long unsigned int D.32659;
  _Bool D.32660;
  long int D.32661;
  long int D.32662;
  long unsigned int D.32669;
  long unsigned int D.32670;
  _Bool D.32671;
  long int D.32672;
  long int D.32673;
  char * D.32680;
  long int D.32681;
  char * D.32683;
  long int D.32684;
  struct MonoException * D.32685;
  long unsigned int D.32686;
  struct MonoType * D.32687;
  long unsigned int D.32691;
  char * D.32693;
  long int D.32694;
  long unsigned int D.32696;
  unsigned int D.32697;
  unsigned char D.32698;
  long unsigned int D.32699;
  long unsigned int D.32700;
  long unsigned int D.32701;
  uintptr_t * D.32702;
  char * D.32703;
  long unsigned int D.32704;
  long unsigned int D.32707;
  long unsigned int D.32708;
  long unsigned int D.32709;
  uintptr_t * D.32710;
  char * D.32711;
  long unsigned int D.32712;
  unsigned int D.32713;
  long unsigned int D.32714;
  struct MonoVTable * D.32716;
  struct MonoDomain * D.32717;
  long unsigned int D.32718;
  intptr_t * D.32719;
  struct MonoArray * D.32720;
  struct MonoClass * aklass;
  struct MonoClass * klass;
  struct MonoArray * array;
  uintptr_t * sizes;
  uintptr_t i;
  gboolean bounded;

  bounded = 0;
  D.32645 = type == 0B;
  D.32646 = (long int) D.32645;
  D.32647 = __builtin_expect (D.32646, 0);
  if (D.32647 != 0) goto <D.32648>; else goto <D.32649>;
  <D.32648>:
  {
    struct MonoException * ex;

    if (type != 0B) goto <D.32650>; else goto <D.32651>;
    <D.32650>:
    <D.32651>:
    ex = mono_get_exception_argument_null ("type");
    mono_raise_exception (ex);
  }
  <D.32649>:
  D.32652 = lengths == 0B;
  D.32653 = (long int) D.32652;
  D.32654 = __builtin_expect (D.32653, 0);
  if (D.32654 != 0) goto <D.32655>; else goto <D.32656>;
  <D.32655>:
  {
    struct MonoException * ex;

    if (lengths != 0B) goto <D.32657>; else goto <D.32658>;
    <D.32657>:
    <D.32658>:
    ex = mono_get_exception_argument_null ("lengths");
    mono_raise_exception (ex);
  }
  <D.32656>:
  D.32659 = mono_array_length (lengths);
  D.32660 = D.32659 == 0;
  D.32661 = (long int) D.32660;
  D.32662 = __builtin_expect (D.32661, 0);
  if (D.32662 != 0) goto <D.32663>; else goto <D.32664>;
  <D.32663>:
  {
    struct MonoException * ex;
    char * msg;

    msg = monoeg_g_strdup_printf ("assertion `%s\' failed", "mono_array_length (lengths) > 0");
    if (lengths != 0B) goto <D.32665>; else goto <D.32666>;
    <D.32665>:
    <D.32666>:
    ex = mono_get_exception_argument ("lengths", msg);
    monoeg_g_free (msg);
    mono_raise_exception (ex);
  }
  <D.32664>:
  if (bounds != 0B) goto <D.32667>; else goto <D.32668>;
  <D.32667>:
  D.32669 = mono_array_length (lengths);
  D.32670 = mono_array_length (bounds);
  D.32671 = D.32669 != D.32670;
  D.32672 = (long int) D.32671;
  D.32673 = __builtin_expect (D.32672, 0);
  if (D.32673 != 0) goto <D.32674>; else goto <D.32675>;
  <D.32674>:
  {
    struct MonoException * ex;
    char * msg;

    msg = monoeg_g_strdup_printf ("assertion `%s\' failed", "mono_array_length (lengths) == mono_array_length (bounds)");
    if (bounds != 0B) goto <D.32676>; else goto <D.32677>;
    <D.32676>:
    <D.32677>:
    ex = mono_get_exception_argument ("bounds", msg);
    monoeg_g_free (msg);
    mono_raise_exception (ex);
  }
  <D.32675>:
  <D.32668>:
  i = 0;
  goto <D.21501>;
  <D.21500>:
  D.32680 = mono_array_addr_with_size (lengths, 8, i);
  D.32681 = MEM[(gint64 *)D.32680];
  if (D.32681 < 0) goto <D.32678>; else goto <D.32682>;
  <D.32682>:
  D.32683 = mono_array_addr_with_size (lengths, 8, i);
  D.32684 = MEM[(gint64 *)D.32683];
  if (D.32684 > 2147483647) goto <D.32678>; else goto <D.32679>;
  <D.32678>:
  D.32685 = mono_get_exception_argument_out_of_range (0B);
  mono_raise_exception (D.32685);
  <D.32679>:
  i = i + 1;
  <D.21501>:
  D.32686 = mono_array_length (lengths);
  if (D.32686 > i) goto <D.21500>; else goto <D.21502>;
  <D.21502>:
  D.32687 = type->type;
  klass = mono_class_from_mono_type (D.32687);
  mono_class_init_or_throw (klass);
  if (bounds != 0B) goto <D.32690>; else goto <D.32688>;
  <D.32690>:
  D.32691 = mono_array_length (bounds);
  if (D.32691 == 1) goto <D.32692>; else goto <D.32688>;
  <D.32692>:
  D.32693 = mono_array_addr_with_size (bounds, 8, 0);
  D.32694 = MEM[(gint64 *)D.32693];
  if (D.32694 != 0) goto <D.32695>; else goto <D.32688>;
  <D.32695>:
  bounded = 1;
  goto <D.32689>;
  <D.32688>:
  bounded = 0;
  <D.32689>:
  D.32696 = mono_array_length (lengths);
  D.32697 = (unsigned int) D.32696;
  aklass = mono_bounded_array_class_get (klass, D.32697, bounded);
  D.32698 = aklass->rank;
  D.32699 = (long unsigned int) D.32698;
  D.32700 = D.32699 * 16;
  sizes = __builtin_alloca (D.32700);
  i = 0;
  goto <D.21504>;
  <D.21503>:
  D.32701 = i * 8;
  D.32702 = sizes + D.32701;
  D.32703 = mono_array_addr_with_size (lengths, 8, i);
  D.32704 = MEM[(guint64 *)D.32703];
  *D.32702 = D.32704;
  if (bounds != 0B) goto <D.32705>; else goto <D.32706>;
  <D.32705>:
  D.32698 = aklass->rank;
  D.32707 = (long unsigned int) D.32698;
  D.32708 = D.32707 + i;
  D.32709 = D.32708 * 8;
  D.32710 = sizes + D.32709;
  D.32711 = mono_array_addr_with_size (bounds, 8, i);
  D.32712 = MEM[(guint64 *)D.32711];
  D.32713 = (unsigned int) D.32712;
  D.32714 = (long unsigned int) D.32713;
  *D.32710 = D.32714;
  goto <D.32715>;
  <D.32706>:
  D.32698 = aklass->rank;
  D.32707 = (long unsigned int) D.32698;
  D.32708 = D.32707 + i;
  D.32709 = D.32708 * 8;
  D.32710 = sizes + D.32709;
  *D.32710 = 0;
  <D.32715>:
  i = i + 1;
  <D.21504>:
  D.32698 = aklass->rank;
  D.32707 = (long unsigned int) D.32698;
  if (D.32707 > i) goto <D.21503>; else goto <D.21505>;
  <D.21505>:
  D.32716 = MEM[(struct MonoObject *)type].vtable;
  D.32717 = D.32716->domain;
  D.32698 = aklass->rank;
  D.32699 = (long unsigned int) D.32698;
  D.32718 = D.32699 * 8;
  D.32719 = sizes + D.32718;
  array = mono_array_new_full (D.32717, aklass, sizes, D.32719);
  D.32720 = array;
  return D.32720;
}


ves_icall_System_Array_CreateInstanceImpl (struct MonoReflectionType * type, struct MonoArray * lengths, struct MonoArray * bounds)
{
  _Bool D.32722;
  long int D.32723;
  long int D.32724;
  _Bool D.32729;
  long int D.32730;
  long int D.32731;
  long unsigned int D.32736;
  _Bool D.32737;
  long int D.32738;
  long int D.32739;
  long unsigned int D.32746;
  long unsigned int D.32747;
  _Bool D.32748;
  long int D.32749;
  long int D.32750;
  char * D.32755;
  int D.32756;
  struct MonoException * D.32759;
  long unsigned int D.32760;
  struct MonoType * D.32761;
  long unsigned int D.32765;
  char * D.32767;
  int D.32768;
  long unsigned int D.32770;
  unsigned int D.32771;
  unsigned char D.32772;
  long unsigned int D.32773;
  long unsigned int D.32774;
  long unsigned int D.32775;
  uintptr_t * D.32776;
  char * D.32777;
  unsigned int D.32778;
  long unsigned int D.32779;
  long unsigned int D.32782;
  long unsigned int D.32783;
  long unsigned int D.32784;
  uintptr_t * D.32785;
  char * D.32786;
  int D.32787;
  long unsigned int D.32788;
  struct MonoVTable * D.32790;
  struct MonoDomain * D.32791;
  long unsigned int D.32792;
  intptr_t * D.32793;
  struct MonoArray * D.32794;
  struct MonoClass * aklass;
  struct MonoClass * klass;
  struct MonoArray * array;
  uintptr_t * sizes;
  uintptr_t i;
  gboolean bounded;

  bounded = 0;
  D.32722 = type == 0B;
  D.32723 = (long int) D.32722;
  D.32724 = __builtin_expect (D.32723, 0);
  if (D.32724 != 0) goto <D.32725>; else goto <D.32726>;
  <D.32725>:
  {
    struct MonoException * ex;

    if (type != 0B) goto <D.32727>; else goto <D.32728>;
    <D.32727>:
    <D.32728>:
    ex = mono_get_exception_argument_null ("type");
    mono_raise_exception (ex);
  }
  <D.32726>:
  D.32729 = lengths == 0B;
  D.32730 = (long int) D.32729;
  D.32731 = __builtin_expect (D.32730, 0);
  if (D.32731 != 0) goto <D.32732>; else goto <D.32733>;
  <D.32732>:
  {
    struct MonoException * ex;

    if (lengths != 0B) goto <D.32734>; else goto <D.32735>;
    <D.32734>:
    <D.32735>:
    ex = mono_get_exception_argument_null ("lengths");
    mono_raise_exception (ex);
  }
  <D.32733>:
  D.32736 = mono_array_length (lengths);
  D.32737 = D.32736 == 0;
  D.32738 = (long int) D.32737;
  D.32739 = __builtin_expect (D.32738, 0);
  if (D.32739 != 0) goto <D.32740>; else goto <D.32741>;
  <D.32740>:
  {
    struct MonoException * ex;
    char * msg;

    msg = monoeg_g_strdup_printf ("assertion `%s\' failed", "mono_array_length (lengths) > 0");
    if (lengths != 0B) goto <D.32742>; else goto <D.32743>;
    <D.32742>:
    <D.32743>:
    ex = mono_get_exception_argument ("lengths", msg);
    monoeg_g_free (msg);
    mono_raise_exception (ex);
  }
  <D.32741>:
  if (bounds != 0B) goto <D.32744>; else goto <D.32745>;
  <D.32744>:
  D.32746 = mono_array_length (lengths);
  D.32747 = mono_array_length (bounds);
  D.32748 = D.32746 != D.32747;
  D.32749 = (long int) D.32748;
  D.32750 = __builtin_expect (D.32749, 0);
  if (D.32750 != 0) goto <D.32751>; else goto <D.32752>;
  <D.32751>:
  {
    struct MonoException * ex;
    char * msg;

    msg = monoeg_g_strdup_printf ("assertion `%s\' failed", "mono_array_length (lengths) == mono_array_length (bounds)");
    if (bounds != 0B) goto <D.32753>; else goto <D.32754>;
    <D.32753>:
    <D.32754>:
    ex = mono_get_exception_argument ("bounds", msg);
    monoeg_g_free (msg);
    mono_raise_exception (ex);
  }
  <D.32752>:
  <D.32745>:
  i = 0;
  goto <D.21478>;
  <D.21477>:
  D.32755 = mono_array_addr_with_size (lengths, 4, i);
  D.32756 = MEM[(gint32 *)D.32755];
  if (D.32756 < 0) goto <D.32757>; else goto <D.32758>;
  <D.32757>:
  D.32759 = mono_get_exception_argument_out_of_range (0B);
  mono_raise_exception (D.32759);
  <D.32758>:
  i = i + 1;
  <D.21478>:
  D.32760 = mono_array_length (lengths);
  if (D.32760 > i) goto <D.21477>; else goto <D.21479>;
  <D.21479>:
  D.32761 = type->type;
  klass = mono_class_from_mono_type (D.32761);
  mono_class_init_or_throw (klass);
  if (bounds != 0B) goto <D.32764>; else goto <D.32762>;
  <D.32764>:
  D.32765 = mono_array_length (bounds);
  if (D.32765 == 1) goto <D.32766>; else goto <D.32762>;
  <D.32766>:
  D.32767 = mono_array_addr_with_size (bounds, 4, 0);
  D.32768 = MEM[(gint32 *)D.32767];
  if (D.32768 != 0) goto <D.32769>; else goto <D.32762>;
  <D.32769>:
  bounded = 1;
  goto <D.32763>;
  <D.32762>:
  bounded = 0;
  <D.32763>:
  D.32770 = mono_array_length (lengths);
  D.32771 = (unsigned int) D.32770;
  aklass = mono_bounded_array_class_get (klass, D.32771, bounded);
  D.32772 = aklass->rank;
  D.32773 = (long unsigned int) D.32772;
  D.32774 = D.32773 * 16;
  sizes = __builtin_alloca (D.32774);
  i = 0;
  goto <D.21481>;
  <D.21480>:
  D.32775 = i * 8;
  D.32776 = sizes + D.32775;
  D.32777 = mono_array_addr_with_size (lengths, 4, i);
  D.32778 = MEM[(guint32 *)D.32777];
  D.32779 = (long unsigned int) D.32778;
  *D.32776 = D.32779;
  if (bounds != 0B) goto <D.32780>; else goto <D.32781>;
  <D.32780>:
  D.32772 = aklass->rank;
  D.32782 = (long unsigned int) D.32772;
  D.32783 = D.32782 + i;
  D.32784 = D.32783 * 8;
  D.32785 = sizes + D.32784;
  D.32786 = mono_array_addr_with_size (bounds, 4, i);
  D.32787 = MEM[(gint32 *)D.32786];
  D.32788 = (long unsigned int) D.32787;
  *D.32785 = D.32788;
  goto <D.32789>;
  <D.32781>:
  D.32772 = aklass->rank;
  D.32782 = (long unsigned int) D.32772;
  D.32783 = D.32782 + i;
  D.32784 = D.32783 * 8;
  D.32785 = sizes + D.32784;
  *D.32785 = 0;
  <D.32789>:
  i = i + 1;
  <D.21481>:
  D.32772 = aklass->rank;
  D.32782 = (long unsigned int) D.32772;
  if (D.32782 > i) goto <D.21480>; else goto <D.21482>;
  <D.21482>:
  D.32790 = MEM[(struct MonoObject *)type].vtable;
  D.32791 = D.32790->domain;
  D.32772 = aklass->rank;
  D.32773 = (long unsigned int) D.32772;
  D.32792 = D.32773 * 8;
  D.32793 = sizes + D.32792;
  array = mono_array_new_full (D.32791, aklass, sizes, D.32793);
  D.32794 = array;
  return D.32794;
}


ves_icall_System_Array_ClearInternal (struct MonoArray * arr, int idx, int length)
{
  struct MonoVTable * D.32796;
  struct MonoClass * D.32797;
  double[0:] * D.32798;
  int D.32799;
  sizetype D.32800;
  void * D.32801;
  int D.32802;
  long unsigned int D.32803;
  int sz;

  D.32796 = MEM[(struct MonoObject *)arr].vtable;
  D.32797 = D.32796->klass;
  sz = mono_array_element_size (D.32797);
  D.32798 = &arr->vector;
  D.32799 = sz * idx;
  D.32800 = (sizetype) D.32799;
  D.32801 = D.32798 + D.32800;
  D.32802 = length * sz;
  D.32803 = (long unsigned int) D.32802;
  mono_gc_bzero_atomic (D.32801, D.32803);
}


mono_ArgIterator_Setup (struct MonoArgIterator * iter, char * argsp, char * start)
{
  struct MonoMethodSignature * D.32804;
  struct MonoMethodSignature * D.32805;
  short int D.32806;
  int D.32807;
  short unsigned int D.32808;
  int D.32809;
  _Bool D.32810;
  long int D.32811;
  long int D.32812;
  long unsigned int D.32815;
  long unsigned int D.32816;
  _Bool D.32817;
  long int D.32818;
  long int D.32819;
  void * D.32825;
  int D.32826;

  D.32804 = MEM[(struct MonoMethodSignature * *)argsp];
  iter->sig = D.32804;
  D.32805 = iter->sig;
  D.32806 = D.32805->sentinelpos;
  D.32807 = (int) D.32806;
  D.32805 = iter->sig;
  D.32808 = D.32805->param_count;
  D.32809 = (int) D.32808;
  D.32810 = D.32807 > D.32809;
  D.32811 = (long int) D.32810;
  D.32812 = __builtin_expect (D.32811, 0);
  if (D.32812 != 0) goto <D.32813>; else goto <D.32814>;
  <D.32813>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "icall.c", 7168, "iter->sig->sentinelpos <= iter->sig->param_count");
  <D.32814>:
  D.32805 = iter->sig;
  D.32815 = BIT_FIELD_REF <*D.32805, 64, 64>;
  D.32816 = D.32815 & 17732923532771328;
  D.32817 = D.32816 != 1407374883553280;
  D.32818 = (long int) D.32817;
  D.32819 = __builtin_expect (D.32818, 0);
  if (D.32819 != 0) goto <D.32820>; else goto <D.32821>;
  <D.32820>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "icall.c", 7169, "iter->sig->call_convention == MONO_CALL_VARARG");
  <D.32821>:
  iter->next_arg = 0;
  if (start != 0B) goto <D.32822>; else goto <D.32823>;
  <D.32822>:
  iter->args = start;
  goto <D.32824>;
  <D.32823>:
  D.32825 = argsp + 8;
  iter->args = D.32825;
  <D.32824>:
  D.32805 = iter->sig;
  D.32808 = D.32805->param_count;
  D.32809 = (int) D.32808;
  D.32805 = iter->sig;
  D.32806 = D.32805->sentinelpos;
  D.32807 = (int) D.32806;
  D.32826 = D.32809 - D.32807;
  iter->num_args = D.32826;
}


mono_ArgIterator_IntGetNextArgType (struct MonoArgIterator * iter)
{
  struct MonoMethodSignature * D.32827;
  short int D.32828;
  int D.32829;
  int D.32830;
  short unsigned int D.32831;
  int D.32832;
  _Bool D.32833;
  long int D.32834;
  long int D.32835;
  struct MonoType * D.32838;
  gint i;

  D.32827 = iter->sig;
  D.32828 = D.32827->sentinelpos;
  D.32829 = (int) D.32828;
  D.32830 = iter->next_arg;
  i = D.32829 + D.32830;
  D.32827 = iter->sig;
  D.32831 = D.32827->param_count;
  D.32832 = (int) D.32831;
  D.32833 = D.32832 <= i;
  D.32834 = (long int) D.32833;
  D.32835 = __builtin_expect (D.32834, 0);
  if (D.32835 != 0) goto <D.32836>; else goto <D.32837>;
  <D.32836>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "icall.c", 7267, "i < iter->sig->param_count");
  <D.32837>:
  D.32827 = iter->sig;
  D.32838 = D.32827->params[i];
  return D.32838;
}


mono_ArgIterator_IntGetNextArgT (struct MonoArgIterator * iter, struct MonoType * type)
{
  struct MonoMethodSignature * D.32841;
  short int D.32842;
  int D.32843;
  int D.32844;
  int D.32845;
  short unsigned int D.32846;
  unsigned int D.32847;
  _Bool D.32848;
  long int D.32849;
  long int D.32850;
  struct MonoType * D.32853;
  int D.32854;
  struct MonoType * D.32857;
  struct MonoClass * D.32858;
  int D.32859;
  void * D.32860;
  sizetype D.32861;
  void * D.32862;
  int D.32863;
  guint32 i;
  guint32 arg_size;
  gint32 align;
  struct MonoTypedRef res;

  try
    {
      D.32841 = iter->sig;
      D.32842 = D.32841->sentinelpos;
      D.32843 = (int) D.32842;
      D.32844 = iter->next_arg;
      D.32845 = D.32843 + D.32844;
      i = (guint32) D.32845;
      D.32841 = iter->sig;
      D.32846 = D.32841->param_count;
      D.32847 = (unsigned int) D.32846;
      D.32848 = D.32847 <= i;
      D.32849 = (long int) D.32848;
      D.32850 = __builtin_expect (D.32849, 0);
      if (D.32850 != 0) goto <D.32851>; else goto <D.32852>;
      <D.32851>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "icall.c", 7233, "i < iter->sig->param_count");
      <D.32852>:
      goto <D.24000>;
      <D.24001>:
      D.32841 = iter->sig;
      D.32853 = D.32841->params[i];
      D.32854 = mono_metadata_type_equal (type, D.32853);
      if (D.32854 == 0) goto <D.32855>; else goto <D.32856>;
      <D.32855>:
      // predicted unlikely by continue predictor.
      goto <D.24000>;
      <D.32856>:
      D.32841 = iter->sig;
      D.32853 = D.32841->params[i];
      res.type = D.32853;
      D.32857 = res.type;
      D.32858 = mono_class_from_mono_type (D.32857);
      res.klass = D.32858;
      D.32857 = res.type;
      D.32859 = mono_type_stack_size (D.32857, &align);
      arg_size = (guint32) D.32859;
      D.32860 = iter->args;
      res.value = D.32860;
      D.32860 = iter->args;
      D.32861 = (sizetype) arg_size;
      D.32862 = D.32860 + D.32861;
      iter->args = D.32862;
      D.32844 = iter->next_arg;
      D.32863 = D.32844 + 1;
      iter->next_arg = D.32863;
      <retval> = res;
      return <retval>;
      <D.24000>:
      D.32841 = iter->sig;
      D.32846 = D.32841->param_count;
      D.32847 = (unsigned int) D.32846;
      if (D.32847 > i) goto <D.24001>; else goto <D.24002>;
      <D.24002>:
      res.type = 0B;
      res.value = 0B;
      res.klass = 0B;
      <retval> = res;
      return <retval>;
    }
  finally
    {
      align = {CLOBBER};
      res = {CLOBBER};
    }
}


mono_ArgIterator_IntGetNextArg (struct MonoArgIterator * iter)
{
  struct MonoMethodSignature * D.32867;
  short int D.32868;
  int D.32869;
  int D.32870;
  int D.32871;
  short unsigned int D.32872;
  unsigned int D.32873;
  _Bool D.32874;
  long int D.32875;
  long int D.32876;
  struct MonoType * D.32879;
  struct MonoType * D.32880;
  struct MonoClass * D.32881;
  int D.32882;
  void * D.32883;
  sizetype D.32884;
  void * D.32885;
  int D.32886;
  guint32 i;
  guint32 arg_size;
  gint32 align;
  struct MonoTypedRef res;

  try
    {
      D.32867 = iter->sig;
      D.32868 = D.32867->sentinelpos;
      D.32869 = (int) D.32868;
      D.32870 = iter->next_arg;
      D.32871 = D.32869 + D.32870;
      i = (guint32) D.32871;
      D.32867 = iter->sig;
      D.32872 = D.32867->param_count;
      D.32873 = (unsigned int) D.32872;
      D.32874 = D.32873 <= i;
      D.32875 = (long int) D.32874;
      D.32876 = __builtin_expect (D.32875, 0);
      if (D.32876 != 0) goto <D.32877>; else goto <D.32878>;
      <D.32877>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "icall.c", 7193, "i < iter->sig->param_count");
      <D.32878>:
      D.32867 = iter->sig;
      D.32879 = D.32867->params[i];
      res.type = D.32879;
      D.32880 = res.type;
      D.32881 = mono_class_from_mono_type (D.32880);
      res.klass = D.32881;
      D.32880 = res.type;
      D.32882 = mono_type_stack_size (D.32880, &align);
      arg_size = (guint32) D.32882;
      D.32883 = iter->args;
      res.value = D.32883;
      D.32883 = iter->args;
      D.32884 = (sizetype) arg_size;
      D.32885 = D.32883 + D.32884;
      iter->args = D.32885;
      D.32870 = iter->next_arg;
      D.32886 = D.32870 + 1;
      iter->next_arg = D.32886;
      <retval> = res;
      return <retval>;
    }
  finally
    {
      align = {CLOBBER};
      res = {CLOBBER};
    }
}


ves_icall_System_Activator_CreateInstanceInternal (struct MonoReflectionType * type)
{
  struct MonoVTable * D.32889;
  struct MonoType * D.32890;
  int D.32891;
  struct MonoObject * D.32894;
  struct MonoClass * klass;
  struct MonoDomain * domain;

  D.32889 = MEM[(struct MonoObject *)type].vtable;
  domain = D.32889->domain;
  D.32890 = type->type;
  klass = mono_class_from_mono_type (D.32890);
  mono_class_init_or_throw (klass);
  D.32891 = mono_class_is_nullable (klass);
  if (D.32891 != 0) goto <D.32892>; else goto <D.32893>;
  <D.32892>:
  D.32894 = 0B;
  return D.32894;
  <D.32893>:
  D.32894 = mono_object_new (domain, klass);
  return D.32894;
}


ves_icall_Mono_Runtime_GetDisplayName ()
{
  struct MonoRuntimeCallbacks * D.32896;
  char * (*<T2820>) (void) D.32897;
  struct MonoDomain * D.32898;
  struct MonoString * D.32899;
  char * info;
  struct MonoString * display_name;

  D.32896 = mono_get_runtime_callbacks ();
  D.32897 = D.32896->get_runtime_build_info;
  info = D.32897 ();
  D.32898 = mono_domain_get ();
  display_name = mono_string_new (D.32898, info);
  monoeg_g_free (info);
  D.32899 = display_name;
  return D.32899;
}


compare_method_imap (const void * key, const void * elem)
{
  short unsigned int D.32901;
  sizetype D.32902;
  int D.32903;
  int D.25859;
  const char * method_name;

  D.32901 = MEM[(guint16 *)elem];
  D.32902 = (sizetype) D.32901;
  method_name = &icall_names_str + D.32902;
  {
    size_t __s1_len;
    size_t __s2_len;

    D.25859 = __builtin_strcmp (key, method_name);
  }
  D.32903 = D.25859;
  return D.32903;
}


mono_lookup_icall_symbol (struct MonoMethod * m)
{
  struct _IO_FILE * stderr.219;
  const char * D.32906;

  stderr.219 = stderr;
  fprintf (stderr.219, "icall symbol maps not enabled, pass --enable-icall-symbol-map to configure.\n");
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "icall.c", 8216);
  D.32906 = 0B;
  return D.32906;
}


fprintf (struct FILE * restrict __stream, const char * restrict __fmt)
{
  int D.32908;

  D.32908 = __fprintf_chk (__stream, 1, __fmt, __builtin_va_arg_pack ());
  return D.32908;
}


mono_create_icall_signature (const char * sigstr)
{
  struct GHashTable * D.32910;
  struct MonoMethodSignature * D.32913;
  gchar * D.32914;
  int D.32915;
  unsigned int D.32916;
  gchar * D.32917;
  struct MonoType * D.32918;
  int D.32919;
  long unsigned int D.32920;
  long unsigned int D.32921;
  gchar * * D.32922;
  gchar * D.32923;
  struct MonoType * D.32924;
  gchar * * parts;
  int i;
  int len;
  gchar * * tmp;
  struct MonoMethodSignature * res;
  struct MonoMethodSignature * res2;
  struct MonoImage * corlib;

  corlib = mono_defaults.corlib;
  mono_image_lock (corlib);
  D.32910 = corlib->helper_signatures;
  res = monoeg_g_hash_table_lookup (D.32910, sigstr);
  mono_image_unlock (corlib);
  if (res != 0B) goto <D.32911>; else goto <D.32912>;
  <D.32911>:
  D.32913 = res;
  return D.32913;
  <D.32912>:
  parts = monoeg_g_strsplit (sigstr, " ", 256);
  tmp = parts;
  len = 0;
  goto <D.26083>;
  <D.26082>:
  len = len + 1;
  tmp = tmp + 8;
  <D.26083>:
  D.32914 = *tmp;
  if (D.32914 != 0B) goto <D.26082>; else goto <D.26084>;
  <D.26084>:
  D.32915 = len + -1;
  D.32916 = (unsigned int) D.32915;
  res = mono_metadata_signature_alloc (corlib, D.32916);
  res->pinvoke = 1;
  D.32917 = *parts;
  D.32918 = type_from_typename (D.32917);
  res->ret = D.32918;
  i = 1;
  goto <D.26086>;
  <D.26085>:
  D.32919 = i + -1;
  D.32920 = (long unsigned int) i;
  D.32921 = D.32920 * 8;
  D.32922 = parts + D.32921;
  D.32923 = *D.32922;
  D.32924 = type_from_typename (D.32923);
  res->params[D.32919] = D.32924;
  i = i + 1;
  <D.26086>:
  if (i < len) goto <D.26085>; else goto <D.26087>;
  <D.26087>:
  monoeg_g_strfreev (parts);
  mono_image_lock (corlib);
  D.32910 = corlib->helper_signatures;
  res2 = monoeg_g_hash_table_lookup (D.32910, sigstr);
  if (res2 != 0B) goto <D.32925>; else goto <D.32926>;
  <D.32925>:
  res = res2;
  goto <D.32927>;
  <D.32926>:
  D.32910 = corlib->helper_signatures;
  monoeg_g_hash_table_insert_replace (D.32910, sigstr, res, 0);
  <D.32927>:
  mono_image_unlock (corlib);
  D.32913 = res;
  return D.32913;
}


type_from_typename (char * typename)
{
  int D.25917;
  int iftmp.220;
  int D.25916;
  const char[4] * D.32932;
  unsigned char D.32933;
  int D.32934;
  unsigned char D.32935;
  int D.32936;
  const unsigned char * D.32941;
  unsigned char D.32942;
  int D.32943;
  const unsigned char * D.32944;
  unsigned char D.32945;
  int D.32946;
  const unsigned char * D.32951;
  unsigned char D.32952;
  int D.32953;
  const unsigned char * D.32954;
  unsigned char D.32955;
  int D.32956;
  const unsigned char * D.32961;
  unsigned char D.32962;
  int D.32963;
  const unsigned char * D.32964;
  unsigned char D.32965;
  int D.32966;
  int D.25926;
  int iftmp.221;
  int D.25925;
  const char[4] * D.32974;
  unsigned char D.32975;
  int D.32976;
  unsigned char D.32977;
  int D.32978;
  const unsigned char * D.32983;
  unsigned char D.32984;
  int D.32985;
  const unsigned char * D.32986;
  unsigned char D.32987;
  int D.32988;
  const unsigned char * D.32993;
  unsigned char D.32994;
  int D.32995;
  const unsigned char * D.32996;
  unsigned char D.32997;
  int D.32998;
  const unsigned char * D.33003;
  unsigned char D.33004;
  int D.33005;
  const unsigned char * D.33006;
  unsigned char D.33007;
  int D.33008;
  int D.25935;
  int iftmp.222;
  int D.25934;
  const char[5] * D.33016;
  unsigned char D.33017;
  int D.33018;
  unsigned char D.33019;
  int D.33020;
  const unsigned char * D.33025;
  unsigned char D.33026;
  int D.33027;
  const unsigned char * D.33028;
  unsigned char D.33029;
  int D.33030;
  const unsigned char * D.33035;
  unsigned char D.33036;
  int D.33037;
  const unsigned char * D.33038;
  unsigned char D.33039;
  int D.33040;
  const unsigned char * D.33045;
  unsigned char D.33046;
  int D.33047;
  const unsigned char * D.33048;
  unsigned char D.33049;
  int D.33050;
  int D.25944;
  int iftmp.223;
  int D.25943;
  const char[6] * D.33058;
  unsigned char D.33059;
  int D.33060;
  unsigned char D.33061;
  int D.33062;
  const unsigned char * D.33067;
  unsigned char D.33068;
  int D.33069;
  const unsigned char * D.33070;
  unsigned char D.33071;
  int D.33072;
  const unsigned char * D.33077;
  unsigned char D.33078;
  int D.33079;
  const unsigned char * D.33080;
  unsigned char D.33081;
  int D.33082;
  const unsigned char * D.33087;
  unsigned char D.33088;
  int D.33089;
  const unsigned char * D.33090;
  unsigned char D.33091;
  int D.33092;
  int D.25953;
  int iftmp.224;
  int D.25952;
  const char[7] * D.33100;
  unsigned char D.33101;
  int D.33102;
  unsigned char D.33103;
  int D.33104;
  const unsigned char * D.33109;
  unsigned char D.33110;
  int D.33111;
  const unsigned char * D.33112;
  unsigned char D.33113;
  int D.33114;
  const unsigned char * D.33119;
  unsigned char D.33120;
  int D.33121;
  const unsigned char * D.33122;
  unsigned char D.33123;
  int D.33124;
  const unsigned char * D.33129;
  unsigned char D.33130;
  int D.33131;
  const unsigned char * D.33132;
  unsigned char D.33133;
  int D.33134;
  int D.25962;
  int iftmp.225;
  int D.25961;
  const char[5] * D.33142;
  unsigned char D.33143;
  int D.33144;
  unsigned char D.33145;
  int D.33146;
  const unsigned char * D.33151;
  unsigned char D.33152;
  int D.33153;
  const unsigned char * D.33154;
  unsigned char D.33155;
  int D.33156;
  const unsigned char * D.33161;
  unsigned char D.33162;
  int D.33163;
  const unsigned char * D.33164;
  unsigned char D.33165;
  int D.33166;
  const unsigned char * D.33171;
  unsigned char D.33172;
  int D.33173;
  const unsigned char * D.33174;
  unsigned char D.33175;
  int D.33176;
  int D.25971;
  int iftmp.226;
  int D.25970;
  const char[6] * D.33184;
  unsigned char D.33185;
  int D.33186;
  unsigned char D.33187;
  int D.33188;
  const unsigned char * D.33193;
  unsigned char D.33194;
  int D.33195;
  const unsigned char * D.33196;
  unsigned char D.33197;
  int D.33198;
  const unsigned char * D.33203;
  unsigned char D.33204;
  int D.33205;
  const unsigned char * D.33206;
  unsigned char D.33207;
  int D.33208;
  const unsigned char * D.33213;
  unsigned char D.33214;
  int D.33215;
  const unsigned char * D.33216;
  unsigned char D.33217;
  int D.33218;
  int D.25980;
  int iftmp.227;
  int D.25979;
  const char[6] * D.33226;
  unsigned char D.33227;
  int D.33228;
  unsigned char D.33229;
  int D.33230;
  const unsigned char * D.33235;
  unsigned char D.33236;
  int D.33237;
  const unsigned char * D.33238;
  unsigned char D.33239;
  int D.33240;
  const unsigned char * D.33245;
  unsigned char D.33246;
  int D.33247;
  const unsigned char * D.33248;
  unsigned char D.33249;
  int D.33250;
  const unsigned char * D.33255;
  unsigned char D.33256;
  int D.33257;
  const unsigned char * D.33258;
  unsigned char D.33259;
  int D.33260;
  int D.25989;
  int iftmp.228;
  int D.25988;
  const char[7] * D.33268;
  unsigned char D.33269;
  int D.33270;
  unsigned char D.33271;
  int D.33272;
  const unsigned char * D.33277;
  unsigned char D.33278;
  int D.33279;
  const unsigned char * D.33280;
  unsigned char D.33281;
  int D.33282;
  const unsigned char * D.33287;
  unsigned char D.33288;
  int D.33289;
  const unsigned char * D.33290;
  unsigned char D.33291;
  int D.33292;
  const unsigned char * D.33297;
  unsigned char D.33298;
  int D.33299;
  const unsigned char * D.33300;
  unsigned char D.33301;
  int D.33302;
  int D.25998;
  int iftmp.229;
  int D.25997;
  const char[5] * D.33310;
  unsigned char D.33311;
  int D.33312;
  unsigned char D.33313;
  int D.33314;
  const unsigned char * D.33319;
  unsigned char D.33320;
  int D.33321;
  const unsigned char * D.33322;
  unsigned char D.33323;
  int D.33324;
  const unsigned char * D.33329;
  unsigned char D.33330;
  int D.33331;
  const unsigned char * D.33332;
  unsigned char D.33333;
  int D.33334;
  const unsigned char * D.33339;
  unsigned char D.33340;
  int D.33341;
  const unsigned char * D.33342;
  unsigned char D.33343;
  int D.33344;
  int D.26007;
  int iftmp.230;
  int D.26006;
  const char[6] * D.33352;
  unsigned char D.33353;
  int D.33354;
  unsigned char D.33355;
  int D.33356;
  const unsigned char * D.33361;
  unsigned char D.33362;
  int D.33363;
  const unsigned char * D.33364;
  unsigned char D.33365;
  int D.33366;
  const unsigned char * D.33371;
  unsigned char D.33372;
  int D.33373;
  const unsigned char * D.33374;
  unsigned char D.33375;
  int D.33376;
  const unsigned char * D.33381;
  unsigned char D.33382;
  int D.33383;
  const unsigned char * D.33384;
  unsigned char D.33385;
  int D.33386;
  int D.26016;
  int iftmp.231;
  int D.26015;
  const char[6] * D.33394;
  unsigned char D.33395;
  int D.33396;
  unsigned char D.33397;
  int D.33398;
  const unsigned char * D.33403;
  unsigned char D.33404;
  int D.33405;
  const unsigned char * D.33406;
  unsigned char D.33407;
  int D.33408;
  const unsigned char * D.33413;
  unsigned char D.33414;
  int D.33415;
  const unsigned char * D.33416;
  unsigned char D.33417;
  int D.33418;
  const unsigned char * D.33423;
  unsigned char D.33424;
  int D.33425;
  const unsigned char * D.33426;
  unsigned char D.33427;
  int D.33428;
  int D.26025;
  int iftmp.232;
  int D.26024;
  const char[7] * D.33436;
  unsigned char D.33437;
  int D.33438;
  unsigned char D.33439;
  int D.33440;
  const unsigned char * D.33445;
  unsigned char D.33446;
  int D.33447;
  const unsigned char * D.33448;
  unsigned char D.33449;
  int D.33450;
  const unsigned char * D.33455;
  unsigned char D.33456;
  int D.33457;
  const unsigned char * D.33458;
  unsigned char D.33459;
  int D.33460;
  const unsigned char * D.33465;
  unsigned char D.33466;
  int D.33467;
  const unsigned char * D.33468;
  unsigned char D.33469;
  int D.33470;
  int D.26034;
  int iftmp.233;
  int D.26033;
  const char[7] * D.33478;
  unsigned char D.33479;
  int D.33480;
  unsigned char D.33481;
  int D.33482;
  const unsigned char * D.33487;
  unsigned char D.33488;
  int D.33489;
  const unsigned char * D.33490;
  unsigned char D.33491;
  int D.33492;
  const unsigned char * D.33497;
  unsigned char D.33498;
  int D.33499;
  const unsigned char * D.33500;
  unsigned char D.33501;
  int D.33502;
  const unsigned char * D.33507;
  unsigned char D.33508;
  int D.33509;
  const unsigned char * D.33510;
  unsigned char D.33511;
  int D.33512;
  int D.26043;
  int iftmp.234;
  int D.26042;
  const char[4] * D.33520;
  unsigned char D.33521;
  int D.33522;
  unsigned char D.33523;
  int D.33524;
  const unsigned char * D.33529;
  unsigned char D.33530;
  int D.33531;
  const unsigned char * D.33532;
  unsigned char D.33533;
  int D.33534;
  const unsigned char * D.33539;
  unsigned char D.33540;
  int D.33541;
  const unsigned char * D.33542;
  unsigned char D.33543;
  int D.33544;
  const unsigned char * D.33549;
  unsigned char D.33550;
  int D.33551;
  const unsigned char * D.33552;
  unsigned char D.33553;
  int D.33554;
  int D.26052;
  int iftmp.235;
  int D.26051;
  const char[7] * D.33562;
  unsigned char D.33563;
  int D.33564;
  unsigned char D.33565;
  int D.33566;
  const unsigned char * D.33571;
  unsigned char D.33572;
  int D.33573;
  const unsigned char * D.33574;
  unsigned char D.33575;
  int D.33576;
  const unsigned char * D.33581;
  unsigned char D.33582;
  int D.33583;
  const unsigned char * D.33584;
  unsigned char D.33585;
  int D.33586;
  const unsigned char * D.33591;
  unsigned char D.33592;
  int D.33593;
  const unsigned char * D.33594;
  unsigned char D.33595;
  int D.33596;
  int D.26061;
  int iftmp.236;
  int D.26060;
  const char[5] * D.33604;
  unsigned char D.33605;
  int D.33606;
  unsigned char D.33607;
  int D.33608;
  const unsigned char * D.33613;
  unsigned char D.33614;
  int D.33615;
  const unsigned char * D.33616;
  unsigned char D.33617;
  int D.33618;
  const unsigned char * D.33623;
  unsigned char D.33624;
  int D.33625;
  const unsigned char * D.33626;
  unsigned char D.33627;
  int D.33628;
  const unsigned char * D.33633;
  unsigned char D.33634;
  int D.33635;
  const unsigned char * D.33636;
  unsigned char D.33637;
  int D.33638;
  int D.26070;
  int iftmp.237;
  int D.26069;
  const char[8] * D.33646;
  unsigned char D.33647;
  int D.33648;
  unsigned char D.33649;
  int D.33650;
  const unsigned char * D.33655;
  unsigned char D.33656;
  int D.33657;
  const unsigned char * D.33658;
  unsigned char D.33659;
  int D.33660;
  const unsigned char * D.33665;
  unsigned char D.33666;
  int D.33667;
  const unsigned char * D.33668;
  unsigned char D.33669;
  int D.33670;
  const unsigned char * D.33675;
  unsigned char D.33676;
  int D.33677;
  const unsigned char * D.33678;
  unsigned char D.33679;
  int D.33680;
  struct MonoType * D.33685;
  struct MonoClass * klass;

  klass = 0B;
  {
    size_t __s1_len;
    size_t __s2_len;

    __s2_len = 3;
    if (__s2_len <= 3) goto <D.32930>; else goto <D.32931>;
    <D.32930>:
    {
      const unsigned char * __s2;
      int __result;

      __s2 = typename;
      D.32932 = "int";
      D.32933 = MEM[(const unsigned char *)D.32932];
      D.32934 = (int) D.32933;
      D.32935 = *__s2;
      D.32936 = (int) D.32935;
      __result = D.32934 - D.32936;
      {
        if (__s2_len != 0) goto <D.32937>; else goto <D.32938>;
        <D.32937>:
        if (__result == 0) goto <D.32939>; else goto <D.32940>;
        <D.32939>:
        D.32941 = &MEM[(void *)"int" + 1B];
        D.32942 = *D.32941;
        D.32943 = (int) D.32942;
        D.32944 = __s2 + 1;
        D.32945 = *D.32944;
        D.32946 = (int) D.32945;
        __result = D.32943 - D.32946;
        if (__s2_len > 1) goto <D.32947>; else goto <D.32948>;
        <D.32947>:
        if (__result == 0) goto <D.32949>; else goto <D.32950>;
        <D.32949>:
        D.32951 = &MEM[(void *)"int" + 2B];
        D.32952 = *D.32951;
        D.32953 = (int) D.32952;
        D.32954 = __s2 + 2;
        D.32955 = *D.32954;
        D.32956 = (int) D.32955;
        __result = D.32953 - D.32956;
        if (__s2_len > 2) goto <D.32957>; else goto <D.32958>;
        <D.32957>:
        if (__result == 0) goto <D.32959>; else goto <D.32960>;
        <D.32959>:
        D.32961 = &MEM[(void *)"int" + 3B];
        D.32962 = *D.32961;
        D.32963 = (int) D.32962;
        D.32964 = __s2 + 3;
        D.32965 = *D.32964;
        D.32966 = (int) D.32965;
        __result = D.32963 - D.32966;
        <D.32960>:
        <D.32958>:
        <D.32950>:
        <D.32948>:
        <D.32940>:
        <D.32938>:
      }
      D.25916 = __result;
    }
    iftmp.220 = -D.25916;
    goto <D.32967>;
    <D.32931>:
    iftmp.220 = __builtin_strcmp (typename, "int");
    <D.32967>:
    D.25917 = iftmp.220;
  }
  if (D.25917 == 0) goto <D.32968>; else goto <D.32969>;
  <D.32968>:
  klass = mono_defaults.int_class;
  goto <D.32970>;
  <D.32969>:
  {
    size_t __s1_len;
    size_t __s2_len;

    __s2_len = 3;
    if (__s2_len <= 3) goto <D.32972>; else goto <D.32973>;
    <D.32972>:
    {
      const unsigned char * __s2;
      int __result;

      __s2 = typename;
      D.32974 = "ptr";
      D.32975 = MEM[(const unsigned char *)D.32974];
      D.32976 = (int) D.32975;
      D.32977 = *__s2;
      D.32978 = (int) D.32977;
      __result = D.32976 - D.32978;
      {
        if (__s2_len != 0) goto <D.32979>; else goto <D.32980>;
        <D.32979>:
        if (__result == 0) goto <D.32981>; else goto <D.32982>;
        <D.32981>:
        D.32983 = &MEM[(void *)"ptr" + 1B];
        D.32984 = *D.32983;
        D.32985 = (int) D.32984;
        D.32986 = __s2 + 1;
        D.32987 = *D.32986;
        D.32988 = (int) D.32987;
        __result = D.32985 - D.32988;
        if (__s2_len > 1) goto <D.32989>; else goto <D.32990>;
        <D.32989>:
        if (__result == 0) goto <D.32991>; else goto <D.32992>;
        <D.32991>:
        D.32993 = &MEM[(void *)"ptr" + 2B];
        D.32994 = *D.32993;
        D.32995 = (int) D.32994;
        D.32996 = __s2 + 2;
        D.32997 = *D.32996;
        D.32998 = (int) D.32997;
        __result = D.32995 - D.32998;
        if (__s2_len > 2) goto <D.32999>; else goto <D.33000>;
        <D.32999>:
        if (__result == 0) goto <D.33001>; else goto <D.33002>;
        <D.33001>:
        D.33003 = &MEM[(void *)"ptr" + 3B];
        D.33004 = *D.33003;
        D.33005 = (int) D.33004;
        D.33006 = __s2 + 3;
        D.33007 = *D.33006;
        D.33008 = (int) D.33007;
        __result = D.33005 - D.33008;
        <D.33002>:
        <D.33000>:
        <D.32992>:
        <D.32990>:
        <D.32982>:
        <D.32980>:
      }
      D.25925 = __result;
    }
    iftmp.221 = -D.25925;
    goto <D.33009>;
    <D.32973>:
    iftmp.221 = __builtin_strcmp (typename, "ptr");
    <D.33009>:
    D.25926 = iftmp.221;
  }
  if (D.25926 == 0) goto <D.33010>; else goto <D.33011>;
  <D.33010>:
  klass = mono_defaults.int_class;
  goto <D.33012>;
  <D.33011>:
  {
    size_t __s1_len;
    size_t __s2_len;

    __s2_len = 4;
    if (__s2_len <= 3) goto <D.33014>; else goto <D.33015>;
    <D.33014>:
    {
      const unsigned char * __s2;
      int __result;

      __s2 = typename;
      D.33016 = "void";
      D.33017 = MEM[(const unsigned char *)D.33016];
      D.33018 = (int) D.33017;
      D.33019 = *__s2;
      D.33020 = (int) D.33019;
      __result = D.33018 - D.33020;
      {
        if (__s2_len != 0) goto <D.33021>; else goto <D.33022>;
        <D.33021>:
        if (__result == 0) goto <D.33023>; else goto <D.33024>;
        <D.33023>:
        D.33025 = &MEM[(void *)"void" + 1B];
        D.33026 = *D.33025;
        D.33027 = (int) D.33026;
        D.33028 = __s2 + 1;
        D.33029 = *D.33028;
        D.33030 = (int) D.33029;
        __result = D.33027 - D.33030;
        if (__s2_len > 1) goto <D.33031>; else goto <D.33032>;
        <D.33031>:
        if (__result == 0) goto <D.33033>; else goto <D.33034>;
        <D.33033>:
        D.33035 = &MEM[(void *)"void" + 2B];
        D.33036 = *D.33035;
        D.33037 = (int) D.33036;
        D.33038 = __s2 + 2;
        D.33039 = *D.33038;
        D.33040 = (int) D.33039;
        __result = D.33037 - D.33040;
        if (__s2_len > 2) goto <D.33041>; else goto <D.33042>;
        <D.33041>:
        if (__result == 0) goto <D.33043>; else goto <D.33044>;
        <D.33043>:
        D.33045 = &MEM[(void *)"void" + 3B];
        D.33046 = *D.33045;
        D.33047 = (int) D.33046;
        D.33048 = __s2 + 3;
        D.33049 = *D.33048;
        D.33050 = (int) D.33049;
        __result = D.33047 - D.33050;
        <D.33044>:
        <D.33042>:
        <D.33034>:
        <D.33032>:
        <D.33024>:
        <D.33022>:
      }
      D.25934 = __result;
    }
    iftmp.222 = -D.25934;
    goto <D.33051>;
    <D.33015>:
    iftmp.222 = __builtin_strcmp (typename, "void");
    <D.33051>:
    D.25935 = iftmp.222;
  }
  if (D.25935 == 0) goto <D.33052>; else goto <D.33053>;
  <D.33052>:
  klass = mono_defaults.void_class;
  goto <D.33054>;
  <D.33053>:
  {
    size_t __s1_len;
    size_t __s2_len;

    __s2_len = 5;
    if (__s2_len <= 3) goto <D.33056>; else goto <D.33057>;
    <D.33056>:
    {
      const unsigned char * __s2;
      int __result;

      __s2 = typename;
      D.33058 = "int32";
      D.33059 = MEM[(const unsigned char *)D.33058];
      D.33060 = (int) D.33059;
      D.33061 = *__s2;
      D.33062 = (int) D.33061;
      __result = D.33060 - D.33062;
      {
        if (__s2_len != 0) goto <D.33063>; else goto <D.33064>;
        <D.33063>:
        if (__result == 0) goto <D.33065>; else goto <D.33066>;
        <D.33065>:
        D.33067 = &MEM[(void *)"int32" + 1B];
        D.33068 = *D.33067;
        D.33069 = (int) D.33068;
        D.33070 = __s2 + 1;
        D.33071 = *D.33070;
        D.33072 = (int) D.33071;
        __result = D.33069 - D.33072;
        if (__s2_len > 1) goto <D.33073>; else goto <D.33074>;
        <D.33073>:
        if (__result == 0) goto <D.33075>; else goto <D.33076>;
        <D.33075>:
        D.33077 = &MEM[(void *)"int32" + 2B];
        D.33078 = *D.33077;
        D.33079 = (int) D.33078;
        D.33080 = __s2 + 2;
        D.33081 = *D.33080;
        D.33082 = (int) D.33081;
        __result = D.33079 - D.33082;
        if (__s2_len > 2) goto <D.33083>; else goto <D.33084>;
        <D.33083>:
        if (__result == 0) goto <D.33085>; else goto <D.33086>;
        <D.33085>:
        D.33087 = &MEM[(void *)"int32" + 3B];
        D.33088 = *D.33087;
        D.33089 = (int) D.33088;
        D.33090 = __s2 + 3;
        D.33091 = *D.33090;
        D.33092 = (int) D.33091;
        __result = D.33089 - D.33092;
        <D.33086>:
        <D.33084>:
        <D.33076>:
        <D.33074>:
        <D.33066>:
        <D.33064>:
      }
      D.25943 = __result;
    }
    iftmp.223 = -D.25943;
    goto <D.33093>;
    <D.33057>:
    iftmp.223 = __builtin_strcmp (typename, "int32");
    <D.33093>:
    D.25944 = iftmp.223;
  }
  if (D.25944 == 0) goto <D.33094>; else goto <D.33095>;
  <D.33094>:
  klass = mono_defaults.int32_class;
  goto <D.33096>;
  <D.33095>:
  {
    size_t __s1_len;
    size_t __s2_len;

    __s2_len = 6;
    if (__s2_len <= 3) goto <D.33098>; else goto <D.33099>;
    <D.33098>:
    {
      const unsigned char * __s2;
      int __result;

      __s2 = typename;
      D.33100 = "uint32";
      D.33101 = MEM[(const unsigned char *)D.33100];
      D.33102 = (int) D.33101;
      D.33103 = *__s2;
      D.33104 = (int) D.33103;
      __result = D.33102 - D.33104;
      {
        if (__s2_len != 0) goto <D.33105>; else goto <D.33106>;
        <D.33105>:
        if (__result == 0) goto <D.33107>; else goto <D.33108>;
        <D.33107>:
        D.33109 = &MEM[(void *)"uint32" + 1B];
        D.33110 = *D.33109;
        D.33111 = (int) D.33110;
        D.33112 = __s2 + 1;
        D.33113 = *D.33112;
        D.33114 = (int) D.33113;
        __result = D.33111 - D.33114;
        if (__s2_len > 1) goto <D.33115>; else goto <D.33116>;
        <D.33115>:
        if (__result == 0) goto <D.33117>; else goto <D.33118>;
        <D.33117>:
        D.33119 = &MEM[(void *)"uint32" + 2B];
        D.33120 = *D.33119;
        D.33121 = (int) D.33120;
        D.33122 = __s2 + 2;
        D.33123 = *D.33122;
        D.33124 = (int) D.33123;
        __result = D.33121 - D.33124;
        if (__s2_len > 2) goto <D.33125>; else goto <D.33126>;
        <D.33125>:
        if (__result == 0) goto <D.33127>; else goto <D.33128>;
        <D.33127>:
        D.33129 = &MEM[(void *)"uint32" + 3B];
        D.33130 = *D.33129;
        D.33131 = (int) D.33130;
        D.33132 = __s2 + 3;
        D.33133 = *D.33132;
        D.33134 = (int) D.33133;
        __result = D.33131 - D.33134;
        <D.33128>:
        <D.33126>:
        <D.33118>:
        <D.33116>:
        <D.33108>:
        <D.33106>:
      }
      D.25952 = __result;
    }
    iftmp.224 = -D.25952;
    goto <D.33135>;
    <D.33099>:
    iftmp.224 = __builtin_strcmp (typename, "uint32");
    <D.33135>:
    D.25953 = iftmp.224;
  }
  if (D.25953 == 0) goto <D.33136>; else goto <D.33137>;
  <D.33136>:
  klass = mono_defaults.uint32_class;
  goto <D.33138>;
  <D.33137>:
  {
    size_t __s1_len;
    size_t __s2_len;

    __s2_len = 4;
    if (__s2_len <= 3) goto <D.33140>; else goto <D.33141>;
    <D.33140>:
    {
      const unsigned char * __s2;
      int __result;

      __s2 = typename;
      D.33142 = "int8";
      D.33143 = MEM[(const unsigned char *)D.33142];
      D.33144 = (int) D.33143;
      D.33145 = *__s2;
      D.33146 = (int) D.33145;
      __result = D.33144 - D.33146;
      {
        if (__s2_len != 0) goto <D.33147>; else goto <D.33148>;
        <D.33147>:
        if (__result == 0) goto <D.33149>; else goto <D.33150>;
        <D.33149>:
        D.33151 = &MEM[(void *)"int8" + 1B];
        D.33152 = *D.33151;
        D.33153 = (int) D.33152;
        D.33154 = __s2 + 1;
        D.33155 = *D.33154;
        D.33156 = (int) D.33155;
        __result = D.33153 - D.33156;
        if (__s2_len > 1) goto <D.33157>; else goto <D.33158>;
        <D.33157>:
        if (__result == 0) goto <D.33159>; else goto <D.33160>;
        <D.33159>:
        D.33161 = &MEM[(void *)"int8" + 2B];
        D.33162 = *D.33161;
        D.33163 = (int) D.33162;
        D.33164 = __s2 + 2;
        D.33165 = *D.33164;
        D.33166 = (int) D.33165;
        __result = D.33163 - D.33166;
        if (__s2_len > 2) goto <D.33167>; else goto <D.33168>;
        <D.33167>:
        if (__result == 0) goto <D.33169>; else goto <D.33170>;
        <D.33169>:
        D.33171 = &MEM[(void *)"int8" + 3B];
        D.33172 = *D.33171;
        D.33173 = (int) D.33172;
        D.33174 = __s2 + 3;
        D.33175 = *D.33174;
        D.33176 = (int) D.33175;
        __result = D.33173 - D.33176;
        <D.33170>:
        <D.33168>:
        <D.33160>:
        <D.33158>:
        <D.33150>:
        <D.33148>:
      }
      D.25961 = __result;
    }
    iftmp.225 = -D.25961;
    goto <D.33177>;
    <D.33141>:
    iftmp.225 = __builtin_strcmp (typename, "int8");
    <D.33177>:
    D.25962 = iftmp.225;
  }
  if (D.25962 == 0) goto <D.33178>; else goto <D.33179>;
  <D.33178>:
  klass = mono_defaults.sbyte_class;
  goto <D.33180>;
  <D.33179>:
  {
    size_t __s1_len;
    size_t __s2_len;

    __s2_len = 5;
    if (__s2_len <= 3) goto <D.33182>; else goto <D.33183>;
    <D.33182>:
    {
      const unsigned char * __s2;
      int __result;

      __s2 = typename;
      D.33184 = "uint8";
      D.33185 = MEM[(const unsigned char *)D.33184];
      D.33186 = (int) D.33185;
      D.33187 = *__s2;
      D.33188 = (int) D.33187;
      __result = D.33186 - D.33188;
      {
        if (__s2_len != 0) goto <D.33189>; else goto <D.33190>;
        <D.33189>:
        if (__result == 0) goto <D.33191>; else goto <D.33192>;
        <D.33191>:
        D.33193 = &MEM[(void *)"uint8" + 1B];
        D.33194 = *D.33193;
        D.33195 = (int) D.33194;
        D.33196 = __s2 + 1;
        D.33197 = *D.33196;
        D.33198 = (int) D.33197;
        __result = D.33195 - D.33198;
        if (__s2_len > 1) goto <D.33199>; else goto <D.33200>;
        <D.33199>:
        if (__result == 0) goto <D.33201>; else goto <D.33202>;
        <D.33201>:
        D.33203 = &MEM[(void *)"uint8" + 2B];
        D.33204 = *D.33203;
        D.33205 = (int) D.33204;
        D.33206 = __s2 + 2;
        D.33207 = *D.33206;
        D.33208 = (int) D.33207;
        __result = D.33205 - D.33208;
        if (__s2_len > 2) goto <D.33209>; else goto <D.33210>;
        <D.33209>:
        if (__result == 0) goto <D.33211>; else goto <D.33212>;
        <D.33211>:
        D.33213 = &MEM[(void *)"uint8" + 3B];
        D.33214 = *D.33213;
        D.33215 = (int) D.33214;
        D.33216 = __s2 + 3;
        D.33217 = *D.33216;
        D.33218 = (int) D.33217;
        __result = D.33215 - D.33218;
        <D.33212>:
        <D.33210>:
        <D.33202>:
        <D.33200>:
        <D.33192>:
        <D.33190>:
      }
      D.25970 = __result;
    }
    iftmp.226 = -D.25970;
    goto <D.33219>;
    <D.33183>:
    iftmp.226 = __builtin_strcmp (typename, "uint8");
    <D.33219>:
    D.25971 = iftmp.226;
  }
  if (D.25971 == 0) goto <D.33220>; else goto <D.33221>;
  <D.33220>:
  klass = mono_defaults.byte_class;
  goto <D.33222>;
  <D.33221>:
  {
    size_t __s1_len;
    size_t __s2_len;

    __s2_len = 5;
    if (__s2_len <= 3) goto <D.33224>; else goto <D.33225>;
    <D.33224>:
    {
      const unsigned char * __s2;
      int __result;

      __s2 = typename;
      D.33226 = "int16";
      D.33227 = MEM[(const unsigned char *)D.33226];
      D.33228 = (int) D.33227;
      D.33229 = *__s2;
      D.33230 = (int) D.33229;
      __result = D.33228 - D.33230;
      {
        if (__s2_len != 0) goto <D.33231>; else goto <D.33232>;
        <D.33231>:
        if (__result == 0) goto <D.33233>; else goto <D.33234>;
        <D.33233>:
        D.33235 = &MEM[(void *)"int16" + 1B];
        D.33236 = *D.33235;
        D.33237 = (int) D.33236;
        D.33238 = __s2 + 1;
        D.33239 = *D.33238;
        D.33240 = (int) D.33239;
        __result = D.33237 - D.33240;
        if (__s2_len > 1) goto <D.33241>; else goto <D.33242>;
        <D.33241>:
        if (__result == 0) goto <D.33243>; else goto <D.33244>;
        <D.33243>:
        D.33245 = &MEM[(void *)"int16" + 2B];
        D.33246 = *D.33245;
        D.33247 = (int) D.33246;
        D.33248 = __s2 + 2;
        D.33249 = *D.33248;
        D.33250 = (int) D.33249;
        __result = D.33247 - D.33250;
        if (__s2_len > 2) goto <D.33251>; else goto <D.33252>;
        <D.33251>:
        if (__result == 0) goto <D.33253>; else goto <D.33254>;
        <D.33253>:
        D.33255 = &MEM[(void *)"int16" + 3B];
        D.33256 = *D.33255;
        D.33257 = (int) D.33256;
        D.33258 = __s2 + 3;
        D.33259 = *D.33258;
        D.33260 = (int) D.33259;
        __result = D.33257 - D.33260;
        <D.33254>:
        <D.33252>:
        <D.33244>:
        <D.33242>:
        <D.33234>:
        <D.33232>:
      }
      D.25979 = __result;
    }
    iftmp.227 = -D.25979;
    goto <D.33261>;
    <D.33225>:
    iftmp.227 = __builtin_strcmp (typename, "int16");
    <D.33261>:
    D.25980 = iftmp.227;
  }
  if (D.25980 == 0) goto <D.33262>; else goto <D.33263>;
  <D.33262>:
  klass = mono_defaults.int16_class;
  goto <D.33264>;
  <D.33263>:
  {
    size_t __s1_len;
    size_t __s2_len;

    __s2_len = 6;
    if (__s2_len <= 3) goto <D.33266>; else goto <D.33267>;
    <D.33266>:
    {
      const unsigned char * __s2;
      int __result;

      __s2 = typename;
      D.33268 = "uint16";
      D.33269 = MEM[(const unsigned char *)D.33268];
      D.33270 = (int) D.33269;
      D.33271 = *__s2;
      D.33272 = (int) D.33271;
      __result = D.33270 - D.33272;
      {
        if (__s2_len != 0) goto <D.33273>; else goto <D.33274>;
        <D.33273>:
        if (__result == 0) goto <D.33275>; else goto <D.33276>;
        <D.33275>:
        D.33277 = &MEM[(void *)"uint16" + 1B];
        D.33278 = *D.33277;
        D.33279 = (int) D.33278;
        D.33280 = __s2 + 1;
        D.33281 = *D.33280;
        D.33282 = (int) D.33281;
        __result = D.33279 - D.33282;
        if (__s2_len > 1) goto <D.33283>; else goto <D.33284>;
        <D.33283>:
        if (__result == 0) goto <D.33285>; else goto <D.33286>;
        <D.33285>:
        D.33287 = &MEM[(void *)"uint16" + 2B];
        D.33288 = *D.33287;
        D.33289 = (int) D.33288;
        D.33290 = __s2 + 2;
        D.33291 = *D.33290;
        D.33292 = (int) D.33291;
        __result = D.33289 - D.33292;
        if (__s2_len > 2) goto <D.33293>; else goto <D.33294>;
        <D.33293>:
        if (__result == 0) goto <D.33295>; else goto <D.33296>;
        <D.33295>:
        D.33297 = &MEM[(void *)"uint16" + 3B];
        D.33298 = *D.33297;
        D.33299 = (int) D.33298;
        D.33300 = __s2 + 3;
        D.33301 = *D.33300;
        D.33302 = (int) D.33301;
        __result = D.33299 - D.33302;
        <D.33296>:
        <D.33294>:
        <D.33286>:
        <D.33284>:
        <D.33276>:
        <D.33274>:
      }
      D.25988 = __result;
    }
    iftmp.228 = -D.25988;
    goto <D.33303>;
    <D.33267>:
    iftmp.228 = __builtin_strcmp (typename, "uint16");
    <D.33303>:
    D.25989 = iftmp.228;
  }
  if (D.25989 == 0) goto <D.33304>; else goto <D.33305>;
  <D.33304>:
  klass = mono_defaults.uint16_class;
  goto <D.33306>;
  <D.33305>:
  {
    size_t __s1_len;
    size_t __s2_len;

    __s2_len = 4;
    if (__s2_len <= 3) goto <D.33308>; else goto <D.33309>;
    <D.33308>:
    {
      const unsigned char * __s2;
      int __result;

      __s2 = typename;
      D.33310 = "long";
      D.33311 = MEM[(const unsigned char *)D.33310];
      D.33312 = (int) D.33311;
      D.33313 = *__s2;
      D.33314 = (int) D.33313;
      __result = D.33312 - D.33314;
      {
        if (__s2_len != 0) goto <D.33315>; else goto <D.33316>;
        <D.33315>:
        if (__result == 0) goto <D.33317>; else goto <D.33318>;
        <D.33317>:
        D.33319 = &MEM[(void *)"long" + 1B];
        D.33320 = *D.33319;
        D.33321 = (int) D.33320;
        D.33322 = __s2 + 1;
        D.33323 = *D.33322;
        D.33324 = (int) D.33323;
        __result = D.33321 - D.33324;
        if (__s2_len > 1) goto <D.33325>; else goto <D.33326>;
        <D.33325>:
        if (__result == 0) goto <D.33327>; else goto <D.33328>;
        <D.33327>:
        D.33329 = &MEM[(void *)"long" + 2B];
        D.33330 = *D.33329;
        D.33331 = (int) D.33330;
        D.33332 = __s2 + 2;
        D.33333 = *D.33332;
        D.33334 = (int) D.33333;
        __result = D.33331 - D.33334;
        if (__s2_len > 2) goto <D.33335>; else goto <D.33336>;
        <D.33335>:
        if (__result == 0) goto <D.33337>; else goto <D.33338>;
        <D.33337>:
        D.33339 = &MEM[(void *)"long" + 3B];
        D.33340 = *D.33339;
        D.33341 = (int) D.33340;
        D.33342 = __s2 + 3;
        D.33343 = *D.33342;
        D.33344 = (int) D.33343;
        __result = D.33341 - D.33344;
        <D.33338>:
        <D.33336>:
        <D.33328>:
        <D.33326>:
        <D.33318>:
        <D.33316>:
      }
      D.25997 = __result;
    }
    iftmp.229 = -D.25997;
    goto <D.33345>;
    <D.33309>:
    iftmp.229 = __builtin_strcmp (typename, "long");
    <D.33345>:
    D.25998 = iftmp.229;
  }
  if (D.25998 == 0) goto <D.33346>; else goto <D.33347>;
  <D.33346>:
  klass = mono_defaults.int64_class;
  goto <D.33348>;
  <D.33347>:
  {
    size_t __s1_len;
    size_t __s2_len;

    __s2_len = 5;
    if (__s2_len <= 3) goto <D.33350>; else goto <D.33351>;
    <D.33350>:
    {
      const unsigned char * __s2;
      int __result;

      __s2 = typename;
      D.33352 = "ulong";
      D.33353 = MEM[(const unsigned char *)D.33352];
      D.33354 = (int) D.33353;
      D.33355 = *__s2;
      D.33356 = (int) D.33355;
      __result = D.33354 - D.33356;
      {
        if (__s2_len != 0) goto <D.33357>; else goto <D.33358>;
        <D.33357>:
        if (__result == 0) goto <D.33359>; else goto <D.33360>;
        <D.33359>:
        D.33361 = &MEM[(void *)"ulong" + 1B];
        D.33362 = *D.33361;
        D.33363 = (int) D.33362;
        D.33364 = __s2 + 1;
        D.33365 = *D.33364;
        D.33366 = (int) D.33365;
        __result = D.33363 - D.33366;
        if (__s2_len > 1) goto <D.33367>; else goto <D.33368>;
        <D.33367>:
        if (__result == 0) goto <D.33369>; else goto <D.33370>;
        <D.33369>:
        D.33371 = &MEM[(void *)"ulong" + 2B];
        D.33372 = *D.33371;
        D.33373 = (int) D.33372;
        D.33374 = __s2 + 2;
        D.33375 = *D.33374;
        D.33376 = (int) D.33375;
        __result = D.33373 - D.33376;
        if (__s2_len > 2) goto <D.33377>; else goto <D.33378>;
        <D.33377>:
        if (__result == 0) goto <D.33379>; else goto <D.33380>;
        <D.33379>:
        D.33381 = &MEM[(void *)"ulong" + 3B];
        D.33382 = *D.33381;
        D.33383 = (int) D.33382;
        D.33384 = __s2 + 3;
        D.33385 = *D.33384;
        D.33386 = (int) D.33385;
        __result = D.33383 - D.33386;
        <D.33380>:
        <D.33378>:
        <D.33370>:
        <D.33368>:
        <D.33360>:
        <D.33358>:
      }
      D.26006 = __result;
    }
    iftmp.230 = -D.26006;
    goto <D.33387>;
    <D.33351>:
    iftmp.230 = __builtin_strcmp (typename, "ulong");
    <D.33387>:
    D.26007 = iftmp.230;
  }
  if (D.26007 == 0) goto <D.33388>; else goto <D.33389>;
  <D.33388>:
  klass = mono_defaults.uint64_class;
  goto <D.33390>;
  <D.33389>:
  {
    size_t __s1_len;
    size_t __s2_len;

    __s2_len = 5;
    if (__s2_len <= 3) goto <D.33392>; else goto <D.33393>;
    <D.33392>:
    {
      const unsigned char * __s2;
      int __result;

      __s2 = typename;
      D.33394 = "float";
      D.33395 = MEM[(const unsigned char *)D.33394];
      D.33396 = (int) D.33395;
      D.33397 = *__s2;
      D.33398 = (int) D.33397;
      __result = D.33396 - D.33398;
      {
        if (__s2_len != 0) goto <D.33399>; else goto <D.33400>;
        <D.33399>:
        if (__result == 0) goto <D.33401>; else goto <D.33402>;
        <D.33401>:
        D.33403 = &MEM[(void *)"float" + 1B];
        D.33404 = *D.33403;
        D.33405 = (int) D.33404;
        D.33406 = __s2 + 1;
        D.33407 = *D.33406;
        D.33408 = (int) D.33407;
        __result = D.33405 - D.33408;
        if (__s2_len > 1) goto <D.33409>; else goto <D.33410>;
        <D.33409>:
        if (__result == 0) goto <D.33411>; else goto <D.33412>;
        <D.33411>:
        D.33413 = &MEM[(void *)"float" + 2B];
        D.33414 = *D.33413;
        D.33415 = (int) D.33414;
        D.33416 = __s2 + 2;
        D.33417 = *D.33416;
        D.33418 = (int) D.33417;
        __result = D.33415 - D.33418;
        if (__s2_len > 2) goto <D.33419>; else goto <D.33420>;
        <D.33419>:
        if (__result == 0) goto <D.33421>; else goto <D.33422>;
        <D.33421>:
        D.33423 = &MEM[(void *)"float" + 3B];
        D.33424 = *D.33423;
        D.33425 = (int) D.33424;
        D.33426 = __s2 + 3;
        D.33427 = *D.33426;
        D.33428 = (int) D.33427;
        __result = D.33425 - D.33428;
        <D.33422>:
        <D.33420>:
        <D.33412>:
        <D.33410>:
        <D.33402>:
        <D.33400>:
      }
      D.26015 = __result;
    }
    iftmp.231 = -D.26015;
    goto <D.33429>;
    <D.33393>:
    iftmp.231 = __builtin_strcmp (typename, "float");
    <D.33429>:
    D.26016 = iftmp.231;
  }
  if (D.26016 == 0) goto <D.33430>; else goto <D.33431>;
  <D.33430>:
  klass = mono_defaults.single_class;
  goto <D.33432>;
  <D.33431>:
  {
    size_t __s1_len;
    size_t __s2_len;

    __s2_len = 6;
    if (__s2_len <= 3) goto <D.33434>; else goto <D.33435>;
    <D.33434>:
    {
      const unsigned char * __s2;
      int __result;

      __s2 = typename;
      D.33436 = "double";
      D.33437 = MEM[(const unsigned char *)D.33436];
      D.33438 = (int) D.33437;
      D.33439 = *__s2;
      D.33440 = (int) D.33439;
      __result = D.33438 - D.33440;
      {
        if (__s2_len != 0) goto <D.33441>; else goto <D.33442>;
        <D.33441>:
        if (__result == 0) goto <D.33443>; else goto <D.33444>;
        <D.33443>:
        D.33445 = &MEM[(void *)"double" + 1B];
        D.33446 = *D.33445;
        D.33447 = (int) D.33446;
        D.33448 = __s2 + 1;
        D.33449 = *D.33448;
        D.33450 = (int) D.33449;
        __result = D.33447 - D.33450;
        if (__s2_len > 1) goto <D.33451>; else goto <D.33452>;
        <D.33451>:
        if (__result == 0) goto <D.33453>; else goto <D.33454>;
        <D.33453>:
        D.33455 = &MEM[(void *)"double" + 2B];
        D.33456 = *D.33455;
        D.33457 = (int) D.33456;
        D.33458 = __s2 + 2;
        D.33459 = *D.33458;
        D.33460 = (int) D.33459;
        __result = D.33457 - D.33460;
        if (__s2_len > 2) goto <D.33461>; else goto <D.33462>;
        <D.33461>:
        if (__result == 0) goto <D.33463>; else goto <D.33464>;
        <D.33463>:
        D.33465 = &MEM[(void *)"double" + 3B];
        D.33466 = *D.33465;
        D.33467 = (int) D.33466;
        D.33468 = __s2 + 3;
        D.33469 = *D.33468;
        D.33470 = (int) D.33469;
        __result = D.33467 - D.33470;
        <D.33464>:
        <D.33462>:
        <D.33454>:
        <D.33452>:
        <D.33444>:
        <D.33442>:
      }
      D.26024 = __result;
    }
    iftmp.232 = -D.26024;
    goto <D.33471>;
    <D.33435>:
    iftmp.232 = __builtin_strcmp (typename, "double");
    <D.33471>:
    D.26025 = iftmp.232;
  }
  if (D.26025 == 0) goto <D.33472>; else goto <D.33473>;
  <D.33472>:
  klass = mono_defaults.double_class;
  goto <D.33474>;
  <D.33473>:
  {
    size_t __s1_len;
    size_t __s2_len;

    __s2_len = 6;
    if (__s2_len <= 3) goto <D.33476>; else goto <D.33477>;
    <D.33476>:
    {
      const unsigned char * __s2;
      int __result;

      __s2 = typename;
      D.33478 = "object";
      D.33479 = MEM[(const unsigned char *)D.33478];
      D.33480 = (int) D.33479;
      D.33481 = *__s2;
      D.33482 = (int) D.33481;
      __result = D.33480 - D.33482;
      {
        if (__s2_len != 0) goto <D.33483>; else goto <D.33484>;
        <D.33483>:
        if (__result == 0) goto <D.33485>; else goto <D.33486>;
        <D.33485>:
        D.33487 = &MEM[(void *)"object" + 1B];
        D.33488 = *D.33487;
        D.33489 = (int) D.33488;
        D.33490 = __s2 + 1;
        D.33491 = *D.33490;
        D.33492 = (int) D.33491;
        __result = D.33489 - D.33492;
        if (__s2_len > 1) goto <D.33493>; else goto <D.33494>;
        <D.33493>:
        if (__result == 0) goto <D.33495>; else goto <D.33496>;
        <D.33495>:
        D.33497 = &MEM[(void *)"object" + 2B];
        D.33498 = *D.33497;
        D.33499 = (int) D.33498;
        D.33500 = __s2 + 2;
        D.33501 = *D.33500;
        D.33502 = (int) D.33501;
        __result = D.33499 - D.33502;
        if (__s2_len > 2) goto <D.33503>; else goto <D.33504>;
        <D.33503>:
        if (__result == 0) goto <D.33505>; else goto <D.33506>;
        <D.33505>:
        D.33507 = &MEM[(void *)"object" + 3B];
        D.33508 = *D.33507;
        D.33509 = (int) D.33508;
        D.33510 = __s2 + 3;
        D.33511 = *D.33510;
        D.33512 = (int) D.33511;
        __result = D.33509 - D.33512;
        <D.33506>:
        <D.33504>:
        <D.33496>:
        <D.33494>:
        <D.33486>:
        <D.33484>:
      }
      D.26033 = __result;
    }
    iftmp.233 = -D.26033;
    goto <D.33513>;
    <D.33477>:
    iftmp.233 = __builtin_strcmp (typename, "object");
    <D.33513>:
    D.26034 = iftmp.233;
  }
  if (D.26034 == 0) goto <D.33514>; else goto <D.33515>;
  <D.33514>:
  klass = mono_defaults.object_class;
  goto <D.33516>;
  <D.33515>:
  {
    size_t __s1_len;
    size_t __s2_len;

    __s2_len = 3;
    if (__s2_len <= 3) goto <D.33518>; else goto <D.33519>;
    <D.33518>:
    {
      const unsigned char * __s2;
      int __result;

      __s2 = typename;
      D.33520 = "obj";
      D.33521 = MEM[(const unsigned char *)D.33520];
      D.33522 = (int) D.33521;
      D.33523 = *__s2;
      D.33524 = (int) D.33523;
      __result = D.33522 - D.33524;
      {
        if (__s2_len != 0) goto <D.33525>; else goto <D.33526>;
        <D.33525>:
        if (__result == 0) goto <D.33527>; else goto <D.33528>;
        <D.33527>:
        D.33529 = &MEM[(void *)"obj" + 1B];
        D.33530 = *D.33529;
        D.33531 = (int) D.33530;
        D.33532 = __s2 + 1;
        D.33533 = *D.33532;
        D.33534 = (int) D.33533;
        __result = D.33531 - D.33534;
        if (__s2_len > 1) goto <D.33535>; else goto <D.33536>;
        <D.33535>:
        if (__result == 0) goto <D.33537>; else goto <D.33538>;
        <D.33537>:
        D.33539 = &MEM[(void *)"obj" + 2B];
        D.33540 = *D.33539;
        D.33541 = (int) D.33540;
        D.33542 = __s2 + 2;
        D.33543 = *D.33542;
        D.33544 = (int) D.33543;
        __result = D.33541 - D.33544;
        if (__s2_len > 2) goto <D.33545>; else goto <D.33546>;
        <D.33545>:
        if (__result == 0) goto <D.33547>; else goto <D.33548>;
        <D.33547>:
        D.33549 = &MEM[(void *)"obj" + 3B];
        D.33550 = *D.33549;
        D.33551 = (int) D.33550;
        D.33552 = __s2 + 3;
        D.33553 = *D.33552;
        D.33554 = (int) D.33553;
        __result = D.33551 - D.33554;
        <D.33548>:
        <D.33546>:
        <D.33538>:
        <D.33536>:
        <D.33528>:
        <D.33526>:
      }
      D.26042 = __result;
    }
    iftmp.234 = -D.26042;
    goto <D.33555>;
    <D.33519>:
    iftmp.234 = __builtin_strcmp (typename, "obj");
    <D.33555>:
    D.26043 = iftmp.234;
  }
  if (D.26043 == 0) goto <D.33556>; else goto <D.33557>;
  <D.33556>:
  klass = mono_defaults.object_class;
  goto <D.33558>;
  <D.33557>:
  {
    size_t __s1_len;
    size_t __s2_len;

    __s2_len = 6;
    if (__s2_len <= 3) goto <D.33560>; else goto <D.33561>;
    <D.33560>:
    {
      const unsigned char * __s2;
      int __result;

      __s2 = typename;
      D.33562 = "string";
      D.33563 = MEM[(const unsigned char *)D.33562];
      D.33564 = (int) D.33563;
      D.33565 = *__s2;
      D.33566 = (int) D.33565;
      __result = D.33564 - D.33566;
      {
        if (__s2_len != 0) goto <D.33567>; else goto <D.33568>;
        <D.33567>:
        if (__result == 0) goto <D.33569>; else goto <D.33570>;
        <D.33569>:
        D.33571 = &MEM[(void *)"string" + 1B];
        D.33572 = *D.33571;
        D.33573 = (int) D.33572;
        D.33574 = __s2 + 1;
        D.33575 = *D.33574;
        D.33576 = (int) D.33575;
        __result = D.33573 - D.33576;
        if (__s2_len > 1) goto <D.33577>; else goto <D.33578>;
        <D.33577>:
        if (__result == 0) goto <D.33579>; else goto <D.33580>;
        <D.33579>:
        D.33581 = &MEM[(void *)"string" + 2B];
        D.33582 = *D.33581;
        D.33583 = (int) D.33582;
        D.33584 = __s2 + 2;
        D.33585 = *D.33584;
        D.33586 = (int) D.33585;
        __result = D.33583 - D.33586;
        if (__s2_len > 2) goto <D.33587>; else goto <D.33588>;
        <D.33587>:
        if (__result == 0) goto <D.33589>; else goto <D.33590>;
        <D.33589>:
        D.33591 = &MEM[(void *)"string" + 3B];
        D.33592 = *D.33591;
        D.33593 = (int) D.33592;
        D.33594 = __s2 + 3;
        D.33595 = *D.33594;
        D.33596 = (int) D.33595;
        __result = D.33593 - D.33596;
        <D.33590>:
        <D.33588>:
        <D.33580>:
        <D.33578>:
        <D.33570>:
        <D.33568>:
      }
      D.26051 = __result;
    }
    iftmp.235 = -D.26051;
    goto <D.33597>;
    <D.33561>:
    iftmp.235 = __builtin_strcmp (typename, "string");
    <D.33597>:
    D.26052 = iftmp.235;
  }
  if (D.26052 == 0) goto <D.33598>; else goto <D.33599>;
  <D.33598>:
  klass = mono_defaults.string_class;
  goto <D.33600>;
  <D.33599>:
  {
    size_t __s1_len;
    size_t __s2_len;

    __s2_len = 4;
    if (__s2_len <= 3) goto <D.33602>; else goto <D.33603>;
    <D.33602>:
    {
      const unsigned char * __s2;
      int __result;

      __s2 = typename;
      D.33604 = "bool";
      D.33605 = MEM[(const unsigned char *)D.33604];
      D.33606 = (int) D.33605;
      D.33607 = *__s2;
      D.33608 = (int) D.33607;
      __result = D.33606 - D.33608;
      {
        if (__s2_len != 0) goto <D.33609>; else goto <D.33610>;
        <D.33609>:
        if (__result == 0) goto <D.33611>; else goto <D.33612>;
        <D.33611>:
        D.33613 = &MEM[(void *)"bool" + 1B];
        D.33614 = *D.33613;
        D.33615 = (int) D.33614;
        D.33616 = __s2 + 1;
        D.33617 = *D.33616;
        D.33618 = (int) D.33617;
        __result = D.33615 - D.33618;
        if (__s2_len > 1) goto <D.33619>; else goto <D.33620>;
        <D.33619>:
        if (__result == 0) goto <D.33621>; else goto <D.33622>;
        <D.33621>:
        D.33623 = &MEM[(void *)"bool" + 2B];
        D.33624 = *D.33623;
        D.33625 = (int) D.33624;
        D.33626 = __s2 + 2;
        D.33627 = *D.33626;
        D.33628 = (int) D.33627;
        __result = D.33625 - D.33628;
        if (__s2_len > 2) goto <D.33629>; else goto <D.33630>;
        <D.33629>:
        if (__result == 0) goto <D.33631>; else goto <D.33632>;
        <D.33631>:
        D.33633 = &MEM[(void *)"bool" + 3B];
        D.33634 = *D.33633;
        D.33635 = (int) D.33634;
        D.33636 = __s2 + 3;
        D.33637 = *D.33636;
        D.33638 = (int) D.33637;
        __result = D.33635 - D.33638;
        <D.33632>:
        <D.33630>:
        <D.33622>:
        <D.33620>:
        <D.33612>:
        <D.33610>:
      }
      D.26060 = __result;
    }
    iftmp.236 = -D.26060;
    goto <D.33639>;
    <D.33603>:
    iftmp.236 = __builtin_strcmp (typename, "bool");
    <D.33639>:
    D.26061 = iftmp.236;
  }
  if (D.26061 == 0) goto <D.33640>; else goto <D.33641>;
  <D.33640>:
  klass = mono_defaults.boolean_class;
  goto <D.33642>;
  <D.33641>:
  {
    size_t __s1_len;
    size_t __s2_len;

    __s2_len = 7;
    if (__s2_len <= 3) goto <D.33644>; else goto <D.33645>;
    <D.33644>:
    {
      const unsigned char * __s2;
      int __result;

      __s2 = typename;
      D.33646 = "boolean";
      D.33647 = MEM[(const unsigned char *)D.33646];
      D.33648 = (int) D.33647;
      D.33649 = *__s2;
      D.33650 = (int) D.33649;
      __result = D.33648 - D.33650;
      {
        if (__s2_len != 0) goto <D.33651>; else goto <D.33652>;
        <D.33651>:
        if (__result == 0) goto <D.33653>; else goto <D.33654>;
        <D.33653>:
        D.33655 = &MEM[(void *)"boolean" + 1B];
        D.33656 = *D.33655;
        D.33657 = (int) D.33656;
        D.33658 = __s2 + 1;
        D.33659 = *D.33658;
        D.33660 = (int) D.33659;
        __result = D.33657 - D.33660;
        if (__s2_len > 1) goto <D.33661>; else goto <D.33662>;
        <D.33661>:
        if (__result == 0) goto <D.33663>; else goto <D.33664>;
        <D.33663>:
        D.33665 = &MEM[(void *)"boolean" + 2B];
        D.33666 = *D.33665;
        D.33667 = (int) D.33666;
        D.33668 = __s2 + 2;
        D.33669 = *D.33668;
        D.33670 = (int) D.33669;
        __result = D.33667 - D.33670;
        if (__s2_len > 2) goto <D.33671>; else goto <D.33672>;
        <D.33671>:
        if (__result == 0) goto <D.33673>; else goto <D.33674>;
        <D.33673>:
        D.33675 = &MEM[(void *)"boolean" + 3B];
        D.33676 = *D.33675;
        D.33677 = (int) D.33676;
        D.33678 = __s2 + 3;
        D.33679 = *D.33678;
        D.33680 = (int) D.33679;
        __result = D.33677 - D.33680;
        <D.33674>:
        <D.33672>:
        <D.33664>:
        <D.33662>:
        <D.33654>:
        <D.33652>:
      }
      D.26069 = __result;
    }
    iftmp.237 = -D.26069;
    goto <D.33681>;
    <D.33645>:
    iftmp.237 = __builtin_strcmp (typename, "boolean");
    <D.33681>:
    D.26070 = iftmp.237;
  }
  if (D.26070 == 0) goto <D.33682>; else goto <D.33683>;
  <D.33682>:
  klass = mono_defaults.boolean_class;
  goto <D.33684>;
  <D.33683>:
  monoeg_g_log (0B, 4, "%s", typename);
  <D.26071>:
  goto <D.26071>;
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "icall.c", 8265);
  <D.33684>:
  <D.33642>:
  <D.33600>:
  <D.33558>:
  <D.33516>:
  <D.33474>:
  <D.33432>:
  <D.33390>:
  <D.33348>:
  <D.33306>:
  <D.33264>:
  <D.33222>:
  <D.33180>:
  <D.33138>:
  <D.33096>:
  <D.33054>:
  <D.33012>:
  <D.32970>:
  D.33685 = &klass->byval_arg;
  return D.33685;
}


mono_find_jit_icall_by_name (const char * name)
{
  struct GHashTable * jit_icall_hash_name.238;
  _Bool D.33688;
  long int D.33689;
  long int D.33690;
  struct MonoJitICallInfo * D.33693;
  struct MonoJitICallInfo * info;

  jit_icall_hash_name.238 = jit_icall_hash_name;
  D.33688 = jit_icall_hash_name.238 == 0B;
  D.33689 = (long int) D.33688;
  D.33690 = __builtin_expect (D.33689, 0);
  if (D.33690 != 0) goto <D.33691>; else goto <D.33692>;
  <D.33691>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "icall.c", 8331, "jit_icall_hash_name");
  <D.33692>:
  mono_icall_lock ();
  jit_icall_hash_name.238 = jit_icall_hash_name;
  info = monoeg_g_hash_table_lookup (jit_icall_hash_name.238, name);
  mono_icall_unlock ();
  D.33693 = info;
  return D.33693;
}


mono_find_jit_icall_by_addr (const void * addr)
{
  struct GHashTable * jit_icall_hash_addr.239;
  _Bool D.33696;
  long int D.33697;
  long int D.33698;
  struct MonoJitICallInfo * D.33701;
  struct MonoJitICallInfo * info;

  jit_icall_hash_addr.239 = jit_icall_hash_addr;
  D.33696 = jit_icall_hash_addr.239 == 0B;
  D.33697 = (long int) D.33696;
  D.33698 = __builtin_expect (D.33697, 0);
  if (D.33698 != 0) goto <D.33699>; else goto <D.33700>;
  <D.33699>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "icall.c", 8343, "jit_icall_hash_addr");
  <D.33700>:
  mono_icall_lock ();
  jit_icall_hash_addr.239 = jit_icall_hash_addr;
  info = monoeg_g_hash_table_lookup (jit_icall_hash_addr.239, addr);
  mono_icall_unlock ();
  D.33701 = info;
  return D.33701;
}


mono_get_jit_icall_info ()
{
  struct GHashTable * D.33703;

  D.33703 = jit_icall_hash_name;
  return D.33703;
}


mono_lookup_jit_icall_symbol (const char * name)
{
  struct GHashTable * jit_icall_hash_name.240;
  const char * D.33708;
  struct MonoJitICallInfo * info;
  const char * res;

  res = 0B;
  mono_icall_lock ();
  jit_icall_hash_name.240 = jit_icall_hash_name;
  info = monoeg_g_hash_table_lookup (jit_icall_hash_name.240, name);
  if (info != 0B) goto <D.33706>; else goto <D.33707>;
  <D.33706>:
  res = info->c_symbol;
  <D.33707>:
  mono_icall_unlock ();
  D.33708 = res;
  return D.33708;
}


mono_register_jit_icall_wrapper (struct MonoJitICallInfo * info, const void * wrapper)
{
  struct GHashTable * jit_icall_hash_addr.241;

  mono_icall_lock ();
  jit_icall_hash_addr.241 = jit_icall_hash_addr;
  monoeg_g_hash_table_insert_replace (jit_icall_hash_addr.241, wrapper, info, 0);
  mono_icall_unlock ();
}


mono_register_jit_icall_full (const void * func, const char * name, struct MonoMethodSignature * sig, gboolean is_save, const char * c_symbol)
{
  _Bool D.33711;
  long int D.33712;
  long int D.33713;
  _Bool D.33716;
  long int D.33717;
  long int D.33718;
  struct GHashTable * jit_icall_hash_name.242;
  struct GHashTable * jit_icall_hash_name.243;
  struct GHashTable * jit_icall_hash_addr.244;
  void * D.33726;
  const char * D.33732;
  struct GHashTable * jit_icall_hash_addr.245;
  struct MonoJitICallInfo * D.33734;
  struct MonoJitICallInfo * info;

  D.33711 = func == 0B;
  D.33712 = (long int) D.33711;
  D.33713 = __builtin_expect (D.33712, 0);
  if (D.33713 != 0) goto <D.33714>; else goto <D.33715>;
  <D.33714>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "icall.c", 8396, "func");
  <D.33715>:
  D.33716 = name == 0B;
  D.33717 = (long int) D.33716;
  D.33718 = __builtin_expect (D.33717, 0);
  if (D.33718 != 0) goto <D.33719>; else goto <D.33720>;
  <D.33719>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "icall.c", 8397, "name");
  <D.33720>:
  mono_icall_lock ();
  jit_icall_hash_name.242 = jit_icall_hash_name;
  if (jit_icall_hash_name.242 == 0B) goto <D.33722>; else goto <D.33723>;
  <D.33722>:
  jit_icall_hash_name.243 = monoeg_g_hash_table_new_full (monoeg_g_str_hash, monoeg_g_str_equal, 0B, monoeg_g_free);
  jit_icall_hash_name = jit_icall_hash_name.243;
  jit_icall_hash_addr.244 = monoeg_g_hash_table_new (0B, 0B);
  jit_icall_hash_addr = jit_icall_hash_addr.244;
  <D.33723>:
  jit_icall_hash_name.242 = jit_icall_hash_name;
  D.33726 = monoeg_g_hash_table_lookup (jit_icall_hash_name.242, name);
  if (D.33726 != 0B) goto <D.33727>; else goto <D.33728>;
  <D.33727>:
  monoeg_g_log (0B, 16, "jit icall already defined \"%s\"\n", name);
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "icall.c", 8408);
  <D.33728>:
  info = monoeg_malloc0 (48);
  info->name = name;
  info->func = func;
  info->sig = sig;
  info->c_symbol = c_symbol;
  if (is_save != 0) goto <D.33729>; else goto <D.33730>;
  <D.33729>:
  info->wrapper = func;
  goto <D.33731>;
  <D.33730>:
  info->wrapper = 0B;
  <D.33731>:
  jit_icall_hash_name.242 = jit_icall_hash_name;
  D.33732 = info->name;
  monoeg_g_hash_table_insert_replace (jit_icall_hash_name.242, D.33732, info, 0);
  jit_icall_hash_addr.245 = jit_icall_hash_addr;
  monoeg_g_hash_table_insert_replace (jit_icall_hash_addr.245, func, info, 0);
  mono_icall_unlock ();
  D.33734 = info;
  return D.33734;
}


mono_register_jit_icall (const void * func, const char * name, struct MonoMethodSignature * sig, gboolean is_save)
{
  struct MonoJitICallInfo * D.33736;

  D.33736 = mono_register_jit_icall_full (func, name, sig, is_save, 0B);
  return D.33736;
}