mono_class_get_methods_by_name (struct MonoClass * klass, const char * name, guint32 bflags, gboolean ignore_case, gboolean allow_ctors, struct MonoException * * ex)
{
  int (*<T3926>) (const char *, const char *) iftmp.0;
  unsigned char D.25235;
  unsigned char D.25236;
  int D.21869;
  int iftmp.1;
  int D.21868;
  const char[7] * D.25244;
  unsigned char D.25245;
  int D.25246;
  unsigned char D.25247;
  int D.25248;
  _Bool D.25249;
  _Bool D.25250;
  _Bool D.25251;
  const unsigned char * D.25254;
  unsigned char D.25255;
  int D.25256;
  const unsigned char * D.25257;
  unsigned char D.25258;
  int D.25259;
  _Bool D.25260;
  _Bool D.25261;
  const unsigned char * D.25264;
  unsigned char D.25265;
  int D.25266;
  const unsigned char * D.25267;
  unsigned char D.25268;
  int D.25269;
  _Bool D.25270;
  _Bool D.25271;
  const unsigned char * D.25274;
  unsigned char D.25275;
  int D.25276;
  const unsigned char * D.25277;
  unsigned char D.25278;
  int D.25279;
  struct MonoLoaderError * D.25285;
  struct GPtrArray * D.25287;
  unsigned char D.25288;
  struct MonoLoaderError * D.25290;
  struct MonoType * D.25292;
  unsigned char D.25293;
  struct MonoClass * D.25296;
  int iftmp.2;
  unsigned int D.25302;
  unsigned int D.25303;
  unsigned char D.25305;
  unsigned int nslots.3;
  int D.25310;
  int D.25311;
  unsigned int D.25312;
  unsigned int D.25313;
  struct MonoLoaderError * D.25316;
  short int D.25318;
  int D.25321;
  _Bool D.25322;
  long int D.25323;
  long int D.25324;
  short int D.25327;
  unsigned int D.25328;
  unsigned int D.25329;
  guint32 * D.25330;
  unsigned int D.25331;
  int D.25332;
  int D.25333;
  unsigned int D.25334;
  unsigned int D.25335;
  short unsigned int D.25338;
  int D.25339;
  int D.25340;
  unsigned int D.25343;
  const char * D.25348;
  char D.25349;
  int D.21881;
  int iftmp.4;
  int D.21880;
  const char[6] * D.25355;
  unsigned char D.25356;
  int D.25357;
  unsigned char D.25358;
  int D.25359;
  _Bool D.25360;
  _Bool D.25361;
  _Bool D.25362;
  const unsigned char * D.25365;
  unsigned char D.25366;
  int D.25367;
  const unsigned char * D.25368;
  unsigned char D.25369;
  int D.25370;
  _Bool D.25371;
  _Bool D.25372;
  const unsigned char * D.25375;
  unsigned char D.25376;
  int D.25377;
  const unsigned char * D.25378;
  unsigned char D.25379;
  int D.25380;
  _Bool D.25381;
  _Bool D.25382;
  const unsigned char * D.25385;
  unsigned char D.25386;
  int D.25387;
  const unsigned char * D.25388;
  unsigned char D.25389;
  int D.25390;
  int D.21890;
  int iftmp.5;
  int D.21889;
  const char[7] * D.25396;
  unsigned char D.25397;
  int D.25398;
  unsigned char D.25399;
  int D.25400;
  _Bool D.25401;
  _Bool D.25402;
  _Bool D.25403;
  const unsigned char * D.25406;
  unsigned char D.25407;
  int D.25408;
  const unsigned char * D.25409;
  unsigned char D.25410;
  int D.25411;
  _Bool D.25412;
  _Bool D.25413;
  const unsigned char * D.25416;
  unsigned char D.25417;
  int D.25418;
  const unsigned char * D.25419;
  unsigned char D.25420;
  int D.25421;
  _Bool D.25422;
  _Bool D.25423;
  const unsigned char * D.25426;
  unsigned char D.25427;
  int D.25428;
  const unsigned char * D.25429;
  unsigned char D.25430;
  int D.25431;
  int D.25433;
  unsigned int D.25436;
  unsigned int D.25440;
  _Bool D.25443;
  int D.25444;
  int D.25445;
  int D.25450;
  unsigned int D.25453;
  unsigned int D.25458;
  unsigned int D.25461;
  int D.25468;
  unsigned int D.25471;
  struct MonoException * D.25481;
  struct MonoLoaderError * D.25483;
  struct MonoException * D.25484;
  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 (*<T3926>) (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.25229>; else goto <D.25230>;
      <D.25229>:
      if (ignore_case != 0) goto <D.25232>; else goto <D.25233>;
      <D.25232>:
      iftmp.0 = monoeg_ascii_strcasecmp;
      goto <D.25234>;
      <D.25233>:
      iftmp.0 = strcmp;
      <D.25234>:
      compare_func = iftmp.0;
      <D.25230>:
      D.25235 = BIT_FIELD_REF <*klass, 8, 184>;
      D.25236 = D.25235 & 1;
      if (D.25236 != 0) goto <D.25237>; else goto <D.25238>;
      <D.25237>:
      if (name != 0B) goto <D.25239>; else goto <D.25240>;
      <D.25239>:
      {
        size_t __s1_len;
        size_t __s2_len;

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

          __s2 = name;
          D.25244 = "Invoke";
          D.25245 = MEM[(const unsigned char *)D.25244];
          D.25246 = (int) D.25245;
          D.25247 = *__s2;
          D.25248 = (int) D.25247;
          __result = D.25246 - D.25248;
          {
            D.25249 = __s2_len != 0;
            D.25250 = __result == 0;
            D.25251 = D.25249 & D.25250;
            if (D.25251 != 0) goto <D.25252>; else goto <D.25253>;
            <D.25252>:
            D.25254 = &MEM[(void *)"Invoke" + 1B];
            D.25255 = *D.25254;
            D.25256 = (int) D.25255;
            D.25257 = __s2 + 1;
            D.25258 = *D.25257;
            D.25259 = (int) D.25258;
            __result = D.25256 - D.25259;
            D.25260 = __s2_len > 1;
            D.25250 = __result == 0;
            D.25261 = D.25260 & D.25250;
            if (D.25261 != 0) goto <D.25262>; else goto <D.25263>;
            <D.25262>:
            D.25264 = &MEM[(void *)"Invoke" + 2B];
            D.25265 = *D.25264;
            D.25266 = (int) D.25265;
            D.25267 = __s2 + 2;
            D.25268 = *D.25267;
            D.25269 = (int) D.25268;
            __result = D.25266 - D.25269;
            D.25270 = __s2_len > 2;
            D.25250 = __result == 0;
            D.25271 = D.25270 & D.25250;
            if (D.25271 != 0) goto <D.25272>; else goto <D.25273>;
            <D.25272>:
            D.25274 = &MEM[(void *)"Invoke" + 3B];
            D.25275 = *D.25274;
            D.25276 = (int) D.25275;
            D.25277 = __s2 + 3;
            D.25278 = *D.25277;
            D.25279 = (int) D.25278;
            __result = D.25276 - D.25279;
            <D.25273>:
            <D.25263>:
            <D.25253>:
          }
          D.21868 = __result;
        }
        iftmp.1 = -D.21868;
        goto <D.25280>;
        <D.25243>:
        iftmp.1 = __builtin_strcmp (name, "Invoke");
        <D.25280>:
        D.21869 = iftmp.1;
      }
      if (D.21869 == 0) goto <D.25281>; else goto <D.25282>;
      <D.25281>:
      if (bflags == 28) goto <D.25283>; else goto <D.25284>;
      <D.25283>:
      method = mono_get_delegate_invoke (klass);
      D.25285 = mono_loader_get_last_error ();
      if (D.25285 != 0B) goto loader_error; else goto <D.25286>;
      <D.25286>:
      monoeg_g_ptr_array_add (array, method);
      D.25287 = array;
      return D.25287;
      <D.25284>:
      <D.25282>:
      <D.25240>:
      <D.25238>:
      mono_class_setup_vtable (klass);
      D.25288 = klass->exception_type;
      if (D.25288 != 0) goto loader_error; else goto <D.25289>;
      <D.25289>:
      D.25290 = mono_loader_get_last_error ();
      if (D.25290 != 0B) goto loader_error; else goto <D.25291>;
      <D.25291>:
      D.25292 = &klass->byval_arg;
      D.25293 = is_generic_parameter (D.25292);
      if (D.25293 != 0) goto <D.25294>; else goto <D.25295>;
      <D.25294>:
      D.25296 = klass->parent;
      nslots = mono_class_get_vtable_size (D.25296);
      goto <D.25297>;
      <D.25295>:
      D.25302 = klass->flags;
      D.25303 = D.25302 & 32;
      if (D.25303 != 0) goto <D.25299>; else goto <D.25304>;
      <D.25304>:
      D.25305 = klass->byval_arg.type;
      if (D.25305 == 19) goto <D.25299>; else goto <D.25306>;
      <D.25306>:
      D.25305 = klass->byval_arg.type;
      if (D.25305 == 30) goto <D.25299>; else goto <D.25300>;
      <D.25299>:
      iftmp.2 = mono_class_num_methods (klass);
      goto <D.25301>;
      <D.25300>:
      iftmp.2 = mono_class_get_vtable_size (klass);
      <D.25301>:
      nslots = iftmp.2;
      <D.25297>:
      nslots.3 = (unsigned int) nslots;
      if (nslots.3 > 255) goto <D.25308>; else goto <D.25309>;
      <D.25308>:
      D.25310 = nslots / 32;
      D.25311 = D.25310 + 1;
      D.25312 = (unsigned int) D.25311;
      D.25313 = D.25312 * 4;
      method_slots = monoeg_malloc0 (D.25313);
      goto <D.25314>;
      <D.25309>:
      method_slots = &method_slots_default;
      memset (method_slots, 0, 32);
      <D.25314>:
      handle_parent:
      mono_class_setup_vtable (klass);
      D.25288 = klass->exception_type;
      if (D.25288 != 0) goto loader_error; else goto <D.25315>;
      <D.25315>:
      D.25316 = mono_loader_get_last_error ();
      if (D.25316 != 0B) goto loader_error; else goto <D.25317>;
      <D.25317>:
      iter = 0B;
      goto <D.21872>;
      <D.21891>:
      match = 0;
      D.25318 = method->slot;
      if (D.25318 != -1) goto <D.25319>; else goto <D.25320>;
      <D.25319>:
      D.25318 = method->slot;
      D.25321 = (int) D.25318;
      D.25322 = D.25321 >= nslots;
      D.25323 = (long int) D.25322;
      D.25324 = __builtin_expect (D.25323, 0);
      if (D.25324 != 0) goto <D.25325>; else goto <D.25326>;
      <D.25325>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "icall.c", 3493, "method->slot < nslots");
      <D.25326>:
      D.25318 = method->slot;
      D.25327 = D.25318 >> 5;
      D.25328 = (unsigned int) D.25327;
      D.25329 = D.25328 * 4;
      D.25330 = method_slots + D.25329;
      D.25331 = *D.25330;
      D.25318 = method->slot;
      D.25321 = (int) D.25318;
      D.25332 = D.25321 & 31;
      D.25333 = 1 << D.25332;
      D.25334 = (unsigned int) D.25333;
      D.25335 = D.25331 & D.25334;
      if (D.25335 != 0) goto <D.25336>; else goto <D.25337>;
      <D.25336>:
      // predicted unlikely by continue predictor.
      goto <D.21872>;
      <D.25337>:
      D.25338 = method->flags;
      D.25339 = (int) D.25338;
      D.25340 = D.25339 & 256;
      if (D.25340 == 0) goto <D.25341>; else goto <D.25342>;
      <D.25341>:
      D.25318 = method->slot;
      D.25327 = D.25318 >> 5;
      D.25328 = (unsigned int) D.25327;
      D.25329 = D.25328 * 4;
      D.25330 = method_slots + D.25329;
      D.25318 = method->slot;
      D.25327 = D.25318 >> 5;
      D.25328 = (unsigned int) D.25327;
      D.25329 = D.25328 * 4;
      D.25330 = method_slots + D.25329;
      D.25331 = *D.25330;
      D.25318 = method->slot;
      D.25321 = (int) D.25318;
      D.25332 = D.25321 & 31;
      D.25333 = 1 << D.25332;
      D.25334 = (unsigned int) D.25333;
      D.25343 = D.25331 | D.25334;
      *D.25330 = D.25343;
      <D.25342>:
      <D.25320>:
      if (allow_ctors == 0) goto <D.25346>; else goto <D.25347>;
      <D.25346>:
      D.25348 = method->name;
      D.25349 = *D.25348;
      if (D.25349 == 46) goto <D.25350>; else goto <D.25351>;
      <D.25350>:
      {
        size_t __s1_len;
        size_t __s2_len;

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

          __s2 = method->name;
          D.25355 = ".ctor";
          D.25356 = MEM[(const unsigned char *)D.25355];
          D.25357 = (int) D.25356;
          D.25358 = *__s2;
          D.25359 = (int) D.25358;
          __result = D.25357 - D.25359;
          {
            D.25360 = __s2_len != 0;
            D.25361 = __result == 0;
            D.25362 = D.25360 & D.25361;
            if (D.25362 != 0) goto <D.25363>; else goto <D.25364>;
            <D.25363>:
            D.25365 = &MEM[(void *)".ctor" + 1B];
            D.25366 = *D.25365;
            D.25367 = (int) D.25366;
            D.25368 = __s2 + 1;
            D.25369 = *D.25368;
            D.25370 = (int) D.25369;
            __result = D.25367 - D.25370;
            D.25371 = __s2_len > 1;
            D.25361 = __result == 0;
            D.25372 = D.25371 & D.25361;
            if (D.25372 != 0) goto <D.25373>; else goto <D.25374>;
            <D.25373>:
            D.25375 = &MEM[(void *)".ctor" + 2B];
            D.25376 = *D.25375;
            D.25377 = (int) D.25376;
            D.25378 = __s2 + 2;
            D.25379 = *D.25378;
            D.25380 = (int) D.25379;
            __result = D.25377 - D.25380;
            D.25381 = __s2_len > 2;
            D.25361 = __result == 0;
            D.25382 = D.25381 & D.25361;
            if (D.25382 != 0) goto <D.25383>; else goto <D.25384>;
            <D.25383>:
            D.25385 = &MEM[(void *)".ctor" + 3B];
            D.25386 = *D.25385;
            D.25387 = (int) D.25386;
            D.25388 = __s2 + 3;
            D.25389 = *D.25388;
            D.25390 = (int) D.25389;
            __result = D.25387 - D.25390;
            <D.25384>:
            <D.25374>:
            <D.25364>:
          }
          D.21880 = __result;
        }
        iftmp.4 = -D.21880;
        goto <D.25391>;
        <D.25354>:
        D.25348 = method->name;
        iftmp.4 = __builtin_strcmp (D.25348, ".ctor");
        <D.25391>:
        D.21881 = iftmp.4;
      }
      if (D.21881 == 0) goto <D.25344>; else goto <D.25392>;
      <D.25392>:
      {
        size_t __s1_len;
        size_t __s2_len;

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

          __s2 = method->name;
          D.25396 = ".cctor";
          D.25397 = MEM[(const unsigned char *)D.25396];
          D.25398 = (int) D.25397;
          D.25399 = *__s2;
          D.25400 = (int) D.25399;
          __result = D.25398 - D.25400;
          {
            D.25401 = __s2_len != 0;
            D.25402 = __result == 0;
            D.25403 = D.25401 & D.25402;
            if (D.25403 != 0) goto <D.25404>; else goto <D.25405>;
            <D.25404>:
            D.25406 = &MEM[(void *)".cctor" + 1B];
            D.25407 = *D.25406;
            D.25408 = (int) D.25407;
            D.25409 = __s2 + 1;
            D.25410 = *D.25409;
            D.25411 = (int) D.25410;
            __result = D.25408 - D.25411;
            D.25412 = __s2_len > 1;
            D.25402 = __result == 0;
            D.25413 = D.25412 & D.25402;
            if (D.25413 != 0) goto <D.25414>; else goto <D.25415>;
            <D.25414>:
            D.25416 = &MEM[(void *)".cctor" + 2B];
            D.25417 = *D.25416;
            D.25418 = (int) D.25417;
            D.25419 = __s2 + 2;
            D.25420 = *D.25419;
            D.25421 = (int) D.25420;
            __result = D.25418 - D.25421;
            D.25422 = __s2_len > 2;
            D.25402 = __result == 0;
            D.25423 = D.25422 & D.25402;
            if (D.25423 != 0) goto <D.25424>; else goto <D.25425>;
            <D.25424>:
            D.25426 = &MEM[(void *)".cctor" + 3B];
            D.25427 = *D.25426;
            D.25428 = (int) D.25427;
            D.25429 = __s2 + 3;
            D.25430 = *D.25429;
            D.25431 = (int) D.25430;
            __result = D.25428 - D.25431;
            <D.25425>:
            <D.25415>:
            <D.25405>:
          }
          D.21889 = __result;
        }
        iftmp.5 = -D.21889;
        goto <D.25432>;
        <D.25395>:
        D.25348 = method->name;
        iftmp.5 = __builtin_strcmp (D.25348, ".cctor");
        <D.25432>:
        D.21890 = iftmp.5;
      }
      if (D.21890 == 0) goto <D.25344>; else goto <D.25345>;
      <D.25344>:
      // predicted unlikely by continue predictor.
      goto <D.21872>;
      <D.25345>:
      <D.25351>:
      <D.25347>:
      D.25338 = method->flags;
      D.25339 = (int) D.25338;
      D.25433 = D.25339 & 7;
      if (D.25433 == 6) goto <D.25434>; else goto <D.25435>;
      <D.25434>:
      D.25436 = bflags & 16;
      if (D.25436 != 0) goto <D.25437>; else goto <D.25438>;
      <D.25437>:
      match = match + 1;
      <D.25438>:
      goto <D.25439>;
      <D.25435>:
      D.25440 = bflags & 32;
      if (D.25440 != 0) goto <D.25441>; else goto <D.25442>;
      <D.25441>:
      D.25443 = klass == startklass;
      D.25444 = (int) D.25443;
      D.25445 = method_nonpublic (method, D.25444);
      if (D.25445 != 0) goto <D.25446>; else goto <D.25447>;
      <D.25446>:
      match = match + 1;
      <D.25447>:
      <D.25442>:
      <D.25439>:
      if (match == 0) goto <D.25448>; else goto <D.25449>;
      <D.25448>:
      // predicted unlikely by continue predictor.
      goto <D.21872>;
      <D.25449>:
      match = 0;
      D.25338 = method->flags;
      D.25339 = (int) D.25338;
      D.25450 = D.25339 & 16;
      if (D.25450 != 0) goto <D.25451>; else goto <D.25452>;
      <D.25451>:
      D.25453 = bflags & 8;
      if (D.25453 != 0) goto <D.25454>; else goto <D.25455>;
      <D.25454>:
      D.25458 = bflags & 64;
      if (D.25458 != 0) goto <D.25456>; else goto <D.25459>;
      <D.25459>:
      if (klass == startklass) goto <D.25456>; else goto <D.25457>;
      <D.25456>:
      match = match + 1;
      <D.25457>:
      <D.25455>:
      goto <D.25460>;
      <D.25452>:
      D.25461 = bflags & 4;
      if (D.25461 != 0) goto <D.25462>; else goto <D.25463>;
      <D.25462>:
      match = match + 1;
      <D.25463>:
      <D.25460>:
      if (match == 0) goto <D.25464>; else goto <D.25465>;
      <D.25464>:
      // predicted unlikely by continue predictor.
      goto <D.21872>;
      <D.25465>:
      if (name != 0B) goto <D.25466>; else goto <D.25467>;
      <D.25466>:
      D.25348 = method->name;
      D.25468 = compare_func (name, D.25348);
      if (D.25468 != 0) goto <D.25469>; else goto <D.25470>;
      <D.25469>:
      // predicted unlikely by continue predictor.
      goto <D.21872>;
      <D.25470>:
      <D.25467>:
      match = 0;
      monoeg_g_ptr_array_add (array, method);
      <D.21872>:
      method = mono_class_get_methods (klass, &iter);
      if (method != 0B) goto <D.21891>; else goto <D.21892>;
      <D.21892>:
      D.25471 = bflags & 2;
      if (D.25471 == 0) goto <D.25472>; else goto <D.25473>;
      <D.25472>:
      klass = klass->parent;
      if (klass != 0B) goto handle_parent; else goto <D.25474>;
      <D.25474>:
      <D.25473>:
      if (&method_slots_default != method_slots) goto <D.25475>; else goto <D.25476>;
      <D.25475>:
      monoeg_g_free (method_slots);
      <D.25476>:
      D.25287 = array;
      return D.25287;
      loader_error:
      if (&method_slots_default != method_slots) goto <D.25477>; else goto <D.25478>;
      <D.25477>:
      monoeg_g_free (method_slots);
      <D.25478>:
      monoeg_g_ptr_array_free (array, 1);
      D.25288 = klass->exception_type;
      if (D.25288 != 0) goto <D.25479>; else goto <D.25480>;
      <D.25479>:
      D.25481 = mono_class_get_exception_for_failure (klass);
      *ex = D.25481;
      goto <D.25482>;
      <D.25480>:
      D.25483 = mono_loader_get_last_error ();
      D.25484 = mono_loader_error_prepare_exception (D.25483);
      *ex = D.25484;
      mono_loader_clear_error ();
      <D.25482>:
      D.25287 = 0B;
      return D.25287;
    }
  finally
    {
      iter = {CLOBBER};
      method_slots_default = {CLOBBER};
    }
}


is_generic_parameter (struct MonoType * type)
{
  MonoBoolean D.25487;
  int iftmp.6;
  unsigned char D.25491;
  unsigned char D.25492;
  unsigned char D.25494;
  _Bool D.25495;
  _Bool D.25496;
  _Bool D.25497;

  D.25491 = BIT_FIELD_REF <*type, 8, 56>;
  D.25492 = D.25491 & 64;
  if (D.25492 == 0) goto <D.25493>; else goto <D.25489>;
  <D.25493>:
  D.25494 = type->type;
  D.25495 = D.25494 == 19;
  D.25496 = D.25494 == 30;
  D.25497 = D.25495 | D.25496;
  if (D.25497 != 0) goto <D.25498>; else goto <D.25489>;
  <D.25498>:
  iftmp.6 = 1;
  goto <D.25490>;
  <D.25489>:
  iftmp.6 = 0;
  <D.25490>:
  D.25487 = (MonoBoolean) iftmp.6;
  return D.25487;
}


memset (void * __dest, int __ch, size_t __len)
{
  int D.25502;
  int D.25507;
  void * D.25509;
  unsigned int D.25510;

  D.25502 = __builtin_constant_p (__len);
  if (D.25502 != 0) goto <D.25503>; else goto <D.25504>;
  <D.25503>:
  if (__len == 0) goto <D.25505>; else goto <D.25506>;
  <D.25505>:
  D.25507 = __builtin_constant_p (__ch);
  if (D.25507 == 0) goto <D.25500>; else goto <D.25508>;
  <D.25508>:
  if (__ch != 0) goto <D.25500>; else goto <D.25501>;
  <D.25500>:
  __warn_memset_zero_len ();
  D.25509 = __dest;
  return D.25509;
  <D.25501>:
  <D.25506>:
  <D.25504>:
  D.25510 = __builtin_object_size (__dest, 0);
  D.25509 = __builtin___memset_chk (__dest, __ch, __len, D.25510);
  return D.25509;
}


method_nonpublic (struct MonoMethod * method, gboolean start_klass)
{
  short unsigned int D.25512;
  int D.25513;
  int D.25514;
  gboolean D.25515;
  int iftmp.7;
  struct MonoClass * D.25521;

  D.25512 = method->flags;
  D.25513 = (int) D.25512;
  D.25514 = D.25513 & 7;
  switch (D.25514) <default: <D.21840>, case 1: <D.21838>, case 3: <D.21837>, case 6: <D.21839>>
  <D.21837>:
  if (start_klass != 0) goto <D.25517>; else goto <D.25520>;
  <D.25520>:
  D.25521 = mono_defaults.generic_ilist_class;
  if (D.25521 != 0B) goto <D.25517>; else goto <D.25518>;
  <D.25517>:
  iftmp.7 = 1;
  goto <D.25519>;
  <D.25518>:
  iftmp.7 = 0;
  <D.25519>:
  D.25515 = iftmp.7;
  return D.25515;
  <D.21838>:
  D.25515 = start_klass;
  return D.25515;
  <D.21839>:
  D.25515 = 0;
  return D.25515;
  <D.21840>:
  D.25515 = 1;
  return D.25515;
}


ves_icall_System_Environment_get_UserName ()
{
  struct MonoString * D.25523;
  const gchar * D.25524;
  struct MonoDomain * D.25525;

  D.25524 = monoeg_g_get_user_name ();
  D.25525 = mono_domain_get ();
  D.25523 = mono_string_new (D.25525, D.25524);
  return D.25523;
}


mono_icall_init ()
{
  int D.24922;
  short unsigned int D.25531;
  sizetype D.25532;
  const char * D.25533;
  const struct IcallTypeDesc * D.25536;
  short unsigned int D.25537;
  int D.25538;
  short unsigned int D.25539;
  int D.25540;
  int D.25541;
  short unsigned int D.25542;
  sizetype D.25543;
  int D.24932;
  struct GHashTable * icall_hash.8;
  int i;

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

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

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

        D.25531 = icall_type_names_idx[i];
        D.25532 = (sizetype) D.25531;
        D.25533 = &icall_type_names_str + D.25532;
        D.24922 = __builtin_strcmp (prev_class, D.25533);
      }
      if (D.24922 >= 0) goto <D.25534>; else goto <D.25535>;
      <D.25534>:
      D.25531 = icall_type_names_idx[i];
      D.25532 = (sizetype) D.25531;
      D.25533 = &icall_type_names_str + D.25532;
      monoeg_g_print ("class %s should come before class %s\n", D.25533, prev_class);
      <D.25535>:
      <D.25530>:
      D.25531 = icall_type_names_idx[i];
      D.25532 = (sizetype) D.25531;
      prev_class = &icall_type_names_str + D.25532;
      desc = &icall_type_descs[i];
      D.25536 = desc + 2;
      D.25537 = D.25536->first_icall;
      D.25538 = (int) D.25537;
      D.25539 = desc->first_icall;
      D.25540 = (int) D.25539;
      num_icalls = D.25538 - D.25540;
      j = 0;
      goto <D.24934>;
      <D.24933>:
      {
        const char * methodn;

        D.25539 = desc->first_icall;
        D.25540 = (int) D.25539;
        D.25541 = D.25540 + j;
        D.25542 = icall_names_idx[D.25541];
        D.25543 = (sizetype) D.25542;
        methodn = &icall_names_str + D.25543;
        if (prev_method != 0B) goto <D.25544>; else goto <D.25545>;
        <D.25544>:
        {
          size_t __s1_len;
          size_t __s2_len;

          D.24932 = __builtin_strcmp (prev_method, methodn);
        }
        if (D.24932 >= 0) goto <D.25546>; else goto <D.25547>;
        <D.25546>:
        monoeg_g_print ("method %s should come before method %s\n", methodn, prev_method);
        <D.25547>:
        <D.25545>:
        prev_method = methodn;
      }
      j = j + 1;
      <D.24934>:
      if (j < num_icalls) goto <D.24933>; else goto <D.24935>;
      <D.24935>:
    }
    i = i + 1;
    <D.24937>:
    if (i <= 107) goto <D.24936>; else goto <D.24938>;
    <D.24938>:
  }
  <D.25528>:
  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)
{
  gchar * D.25552;
  struct GHashTable * icall_hash.12;

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


mono_icall_lock ()
{
  pthread_mutex_lock (&icall_mutex);
}


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

  if (str != 0B) goto <D.25554>; else goto <D.25555>;
  <D.25554>:
  D.25556 = __strdup (str);
  return D.25556;
  <D.25555>:
  D.25556 = 0B;
  return D.25556;
}


mono_icall_unlock ()
{
  pthread_mutex_unlock (&icall_mutex);
}


mono_lookup_internal_call (struct MonoMethod * method)
{
  _Bool D.25558;
  long int D.25559;
  long int D.25560;
  unsigned char D.25563;
  unsigned char D.25564;
  struct MonoClass * D.25567;
  struct MonoClass * D.25568;
  void * D.25573;
  int pos.13;
  unsigned int pos.14;
  unsigned int D.25576;
  int D.25577;
  sizetype pos.15;
  char * D.25579;
  int D.25585;
  const char * D.25586;
  unsigned int D.25587;
  unsigned int mlen.16;
  sizetype typelen.17;
  sizetype D.25590;
  char * D.25591;
  sizetype mlen.18;
  sizetype D.25593;
  sizetype D.25594;
  struct MonoMethodSignature * D.25595;
  unsigned int D.25596;
  int D.25597;
  int D.25598;
  int D.25599;
  unsigned int D.25600;
  unsigned int siglen.19;
  char * D.25604;
  sizetype siglen.20;
  sizetype D.25606;
  char * D.25607;
  sizetype D.25608;
  char * D.25609;
  struct GHashTable * icall_hash.21;
  sizetype D.25617;
  char * D.25618;
  struct MonoImage * D.25623;
  char * D.25624;
  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.25558 = method == 0B;
      D.25559 = (long int) D.25558;
      D.25560 = __builtin_expect (D.25559, 0);
      if (D.25560 != 0) goto <D.25561>; else goto <D.25562>;
      <D.25561>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "icall.c", 8049, "method != NULL");
      <D.25562>:
      D.25563 = BIT_FIELD_REF <*method, 8, 168>;
      D.25564 = D.25563 & 16;
      if (D.25564 != 0) goto <D.25565>; else goto <D.25566>;
      <D.25565>:
      method = MEM[(struct MonoMethodInflated *)method].declaring;
      <D.25566>:
      D.25567 = method->klass;
      D.25568 = D.25567->nested_in;
      if (D.25568 != 0B) goto <D.25569>; else goto <D.25570>;
      <D.25569>:
      {
        int pos;

        D.25567 = method->klass;
        D.25568 = D.25567->nested_in;
        pos = concat_class_name (&mname, 2046, D.25568);
        if (pos == 0) goto <D.25571>; else goto <D.25572>;
        <D.25571>:
        D.25573 = 0B;
        return D.25573;
        <D.25572>:
        pos.13 = pos;
        pos = pos.13 + 1;
        mname[pos.13] = 47;
        mname[pos] = 0;
        D.25567 = method->klass;
        pos.14 = (unsigned int) pos;
        D.25576 = 2047 - pos.14;
        D.25577 = (int) D.25576;
        pos.15 = (sizetype) pos;
        D.25579 = &mname + pos.15;
        typelen = concat_class_name (D.25579, D.25577, D.25567);
        if (typelen == 0) goto <D.25580>; else goto <D.25581>;
        <D.25580>:
        D.25573 = 0B;
        return D.25573;
        <D.25581>:
        typelen = typelen + pos;
      }
      goto <D.25582>;
      <D.25570>:
      D.25567 = method->klass;
      typelen = concat_class_name (&mname, 2048, D.25567);
      if (typelen == 0) goto <D.25583>; else goto <D.25584>;
      <D.25583>:
      D.25573 = 0B;
      return D.25573;
      <D.25584>:
      <D.25582>:
      imap = find_class_icalls (&mname);
      mname[typelen] = 58;
      D.25585 = typelen + 1;
      mname[D.25585] = 58;
      D.25586 = method->name;
      D.25587 = strlen (D.25586);
      mlen = (int) D.25587;
      mlen.16 = (unsigned int) mlen;
      D.25586 = method->name;
      typelen.17 = (sizetype) typelen;
      D.25590 = typelen.17 + 2;
      D.25591 = &mname + D.25590;
      memcpy (D.25591, D.25586, mlen.16);
      typelen.17 = (sizetype) typelen;
      mlen.18 = (sizetype) mlen;
      D.25593 = typelen.17 + mlen.18;
      D.25594 = D.25593 + 2;
      sigstart = &mname + D.25594;
      *sigstart = 0;
      D.25595 = mono_method_signature (method);
      tmpsig = mono_signature_get_desc (D.25595, 1);
      D.25596 = strlen (tmpsig);
      siglen = (int) D.25596;
      D.25597 = typelen + mlen;
      D.25598 = D.25597 + siglen;
      D.25599 = D.25598 + 6;
      D.25600 = (unsigned int) D.25599;
      if (D.25600 > 2048) goto <D.25601>; else goto <D.25602>;
      <D.25601>:
      D.25573 = 0B;
      return D.25573;
      <D.25602>:
      *sigstart = 40;
      siglen.19 = (unsigned int) siglen;
      D.25604 = sigstart + 1;
      memcpy (D.25604, tmpsig, siglen.19);
      siglen.20 = (sizetype) siglen;
      D.25606 = siglen.20 + 1;
      D.25607 = sigstart + D.25606;
      *D.25607 = 41;
      siglen.20 = (sizetype) siglen;
      D.25608 = siglen.20 + 2;
      D.25609 = sigstart + D.25608;
      *D.25609 = 0;
      monoeg_g_free (tmpsig);
      mono_icall_lock ();
      icall_hash.21 = icall_hash;
      res = monoeg_g_hash_table_lookup (icall_hash.21, &mname);
      if (res != 0B) goto <D.25611>; else goto <D.25612>;
      <D.25611>:
      mono_icall_unlock ();
      D.25573 = res;
      return D.25573;
      <D.25612>:
      *sigstart = 0;
      icall_hash.21 = icall_hash;
      res = monoeg_g_hash_table_lookup (icall_hash.21, &mname);
      if (res != 0B) goto <D.25613>; else goto <D.25614>;
      <D.25613>:
      mono_icall_unlock ();
      D.25573 = res;
      return D.25573;
      <D.25614>:
      if (imap == 0B) goto <D.25615>; else goto <D.25616>;
      <D.25615>:
      mono_icall_unlock ();
      D.25573 = 0B;
      return D.25573;
      <D.25616>:
      mlen.18 = (sizetype) mlen;
      D.25617 = -mlen.18;
      D.25618 = sigstart + D.25617;
      res = find_method_icall (imap, D.25618);
      if (res != 0B) goto <D.25619>; else goto <D.25620>;
      <D.25619>:
      mono_icall_unlock ();
      D.25573 = res;
      return D.25573;
      <D.25620>:
      *sigstart = 40;
      mlen.18 = (sizetype) mlen;
      D.25617 = -mlen.18;
      D.25618 = sigstart + D.25617;
      res = find_method_icall (imap, D.25618);
      if (res != 0B) goto <D.25621>; else goto <D.25622>;
      <D.25621>:
      mono_icall_unlock ();
      D.25573 = res;
      return D.25573;
      <D.25622>:
      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.25567 = method->klass;
      D.25623 = D.25567->image;
      D.25624 = D.25623->name;
      monoeg_g_print ("The out of sync library is: %s\n", D.25624);
      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.25573 = 0B;
      return D.25573;
    }
  finally
    {
      mname = {CLOBBER};
    }
}


concat_class_name (char * buf, int bufsize, struct MonoClass * klass)
{
  const char * D.25627;
  unsigned int D.25628;
  const char * D.25629;
  unsigned int D.25630;
  int D.25631;
  int D.25632;
  int D.25635;
  unsigned int nspacelen.22;
  int nspacelen.23;
  sizetype nspacelen.24;
  char * D.25641;
  unsigned int cnamelen.25;
  sizetype nspacelen.26;
  char * D.25644;
  sizetype D.25645;
  char * D.25646;
  int nspacelen;
  int cnamelen;

  D.25627 = klass->name_space;
  D.25628 = strlen (D.25627);
  nspacelen = (int) D.25628;
  D.25629 = klass->name;
  D.25630 = strlen (D.25629);
  cnamelen = (int) D.25630;
  D.25631 = nspacelen + cnamelen;
  D.25632 = D.25631 + 1;
  if (D.25632 >= bufsize) goto <D.25633>; else goto <D.25634>;
  <D.25633>:
  D.25635 = 0;
  return D.25635;
  <D.25634>:
  if (nspacelen != 0) goto <D.25636>; else goto <D.25637>;
  <D.25636>:
  nspacelen.22 = (unsigned int) nspacelen;
  D.25627 = klass->name_space;
  memcpy (buf, D.25627, nspacelen.22);
  nspacelen.23 = nspacelen;
  nspacelen = nspacelen.23 + 1;
  nspacelen.24 = (sizetype) nspacelen.23;
  D.25641 = buf + nspacelen.24;
  *D.25641 = 46;
  <D.25637>:
  cnamelen.25 = (unsigned int) cnamelen;
  D.25629 = klass->name;
  nspacelen.26 = (sizetype) nspacelen;
  D.25644 = buf + nspacelen.26;
  memcpy (D.25644, D.25629, cnamelen.25);
  D.25631 = nspacelen + cnamelen;
  D.25645 = (sizetype) D.25631;
  D.25646 = buf + D.25645;
  *D.25646 = 0;
  D.25635 = nspacelen + cnamelen;
  return D.25635;
}


find_class_icalls (const char * name)
{
  const struct IcallTypeDesc * D.25650;
  int nameslot.27;
  int D.25652;
  int D.25653;
  int D.25654;
  const guint16 * nameslot;

  nameslot = mono_binary_search (name, &icall_type_names_idx, 108, 2, compare_class_imap);
  if (nameslot == 0B) goto <D.25648>; else goto <D.25649>;
  <D.25648>:
  D.25650 = 0B;
  return D.25650;
  <D.25649>:
  nameslot.27 = (int) nameslot;
  D.25652 = (int) &icall_type_names_idx[0];
  D.25653 = nameslot.27 - D.25652;
  D.25654 = D.25653 /[ex] 2;
  D.25650 = &icall_type_descs[D.25654];
  return D.25650;
}


compare_class_imap (const void * key, const void * elem)
{
  short unsigned int D.25656;
  sizetype D.25657;
  int D.25658;
  int D.24984;
  const char * class_name;

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

    D.24984 = __builtin_strcmp (key, class_name);
  }
  D.25658 = D.24984;
  return D.25658;
}


memcpy (void * restrict __dest, const void * restrict __src, size_t __len)
{
  void * D.25660;
  unsigned int D.25661;

  D.25661 = __builtin_object_size (__dest, 0);
  D.25660 = __builtin___memcpy_chk (__dest, __src, __len, D.25661);
  return D.25660;
}


find_method_icall (const struct IcallTypeDesc * imap, const char * name)
{
  const struct IcallTypeDesc * D.25663;
  short unsigned int D.25664;
  int D.25665;
  short unsigned int D.25666;
  int D.25667;
  int D.25668;
  unsigned int D.25669;
  unsigned int D.25670;
  unsigned int D.25671;
  const void * D.25672;
  void * D.25675;
  int nameslot.28;
  int D.25677;
  int D.25678;
  int D.25679;
  const guint16 * nameslot;

  D.25663 = imap + 2;
  D.25664 = D.25663->first_icall;
  D.25665 = (int) D.25664;
  D.25666 = imap->first_icall;
  D.25667 = (int) D.25666;
  D.25668 = D.25665 - D.25667;
  D.25669 = (unsigned int) D.25668;
  D.25666 = imap->first_icall;
  D.25670 = (unsigned int) D.25666;
  D.25671 = D.25670 * 2;
  D.25672 = &icall_names_idx + D.25671;
  nameslot = mono_binary_search (name, D.25672, D.25669, 2, compare_method_imap);
  if (nameslot == 0B) goto <D.25673>; else goto <D.25674>;
  <D.25673>:
  D.25675 = 0B;
  return D.25675;
  <D.25674>:
  nameslot.28 = (int) nameslot;
  D.25677 = (int) &icall_names_idx[0];
  D.25678 = nameslot.28 - D.25677;
  D.25679 = D.25678 /[ex] 2;
  D.25675 = icall_functions[D.25679];
  return D.25675;
}


ves_icall_get_resources_ptr (struct MonoReflectionAssembly * assembly, void * * result, gint32 * size)
{
  _Bool D.25683;
  _Bool D.25684;
  _Bool D.25685;
  gboolean D.25687;
  struct MonoAssembly * D.25688;
  unsigned int D.25691;
  char * D.25692;
  void * D.25693;
  unsigned int D.25696;
  int D.25697;
  struct MonoPEResourceDataEntry * entry;
  struct MonoImage * image;

  D.25683 = assembly == 0B;
  D.25684 = result == 0B;
  D.25685 = D.25683 | D.25684;
  if (D.25685 != 0) goto <D.25681>; else goto <D.25686>;
  <D.25686>:
  if (size == 0B) goto <D.25681>; else goto <D.25682>;
  <D.25681>:
  D.25687 = 0;
  return D.25687;
  <D.25682>:
  *result = 0B;
  *size = 0;
  D.25688 = assembly->assembly;
  image = D.25688->image;
  entry = mono_image_lookup_resource (image, 101, 0, 0B);
  if (entry == 0B) goto <D.25689>; else goto <D.25690>;
  <D.25689>:
  D.25687 = 0;
  return D.25687;
  <D.25690>:
  D.25691 = entry->rde_data_offset;
  D.25692 = mono_image_rva_map (image, D.25691);
  *result = D.25692;
  D.25693 = *result;
  if (D.25693 == 0B) goto <D.25694>; else goto <D.25695>;
  <D.25694>:
  monoeg_g_free (entry);
  D.25687 = 0;
  return D.25687;
  <D.25695>:
  D.25696 = entry->rde_size;
  D.25697 = (int) D.25696;
  *size = D.25697;
  monoeg_g_free (entry);
  D.25687 = 1;
  return D.25687;
}


ves_icall_System_Web_Util_ICalls_get_machine_install_dir ()
{
  const char * D.25699;
  struct MonoDomain * D.25700;
  struct MonoString * D.25701;
  struct MonoString * ipath;
  gchar * path;

  D.25699 = mono_get_config_dir ();
  path = monoeg_g_path_get_dirname (D.25699);
  D.25700 = mono_domain_get ();
  ipath = mono_string_new (D.25700, path);
  monoeg_g_free (path);
  D.25701 = ipath;
  return D.25701;
}


ves_icall_System_ValueType_InternalGetHashCode (struct MonoObject * this, struct MonoArray * * fields)
{
  struct MonoVTable * D.25703;
  int D.25704;
  gint32 D.25707;
  struct MonoType * D.25708;
  short unsigned int D.25709;
  int D.25710;
  int D.25711;
  int D.25714;
  int D.20732;
  int iftmp.29;
  int D.20731;
  const char[9] * D.25720;
  unsigned char D.25721;
  int D.25722;
  unsigned char D.25723;
  int D.25724;
  _Bool D.25725;
  _Bool D.25726;
  _Bool D.25727;
  const unsigned char * D.25730;
  unsigned char D.25731;
  int D.25732;
  const unsigned char * D.25733;
  unsigned char D.25734;
  int D.25735;
  _Bool D.25736;
  _Bool D.25737;
  const unsigned char * D.25740;
  unsigned char D.25741;
  int D.25742;
  const unsigned char * D.25743;
  unsigned char D.25744;
  int D.25745;
  _Bool D.25746;
  _Bool D.25747;
  const unsigned char * D.25750;
  unsigned char D.25751;
  int D.25752;
  const unsigned char * D.25753;
  unsigned char D.25754;
  int D.25755;
  const char * D.25757;
  unsigned char D.25760;
  int D.25761;
  int D.25762;
  sizetype D.25763;
  gint32 * D.25764;
  int D.25765;
  struct MonoString * * D.25766;
  unsigned int D.25769;
  unsigned int result.30;
  unsigned int D.25771;
  int D.25774;
  unsigned int D.25775;
  unsigned int D.25776;
  struct MonoDomain * D.25777;
  int count.31;
  unsigned int count.32;
  unsigned int D.25780;
  struct MonoObject * * D.25781;
  unsigned int count.33;
  struct MonoClass * D.25785;
  struct MonoDomain * D.25786;
  struct MonoArray * D.25787;
  unsigned int i.34;
  struct MonoArray * D.25789;
  unsigned int i.35;
  unsigned int D.25791;
  struct MonoObject * * D.25792;
  struct MonoObject * D.25793;
  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.25703 = this->vtable;
      klass = D.25703->klass;
      D.25704 = mono_class_num_fields (klass);
      if (D.25704 == 0) goto <D.25705>; else goto <D.25706>;
      <D.25705>:
      D.25707 = mono_object_hash (this);
      return D.25707;
      <D.25706>:
      iter = 0B;
      goto <D.20723>;
      <D.20738>:
      D.25708 = field->type;
      D.25709 = D.25708->attrs;
      D.25710 = (int) D.25709;
      D.25711 = D.25710 & 16;
      if (D.25711 != 0) goto <D.25712>; else goto <D.25713>;
      <D.25712>:
      // predicted unlikely by continue predictor.
      goto <D.20723>;
      <D.25713>:
      D.25708 = field->type;
      D.25709 = D.25708->attrs;
      D.25710 = (int) D.25709;
      D.25714 = D.25710 & 1536;
      if (D.25714 != 0) goto <D.25715>; else goto <D.25716>;
      <D.25715>:
      {
        size_t __s1_len;
        size_t __s2_len;

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

          __s2 = mono_field_get_name (field);
          D.25720 = "_Deleted";
          D.25721 = MEM[(const unsigned char *)D.25720];
          D.25722 = (int) D.25721;
          D.25723 = *__s2;
          D.25724 = (int) D.25723;
          __result = D.25722 - D.25724;
          {
            D.25725 = __s2_len != 0;
            D.25726 = __result == 0;
            D.25727 = D.25725 & D.25726;
            if (D.25727 != 0) goto <D.25728>; else goto <D.25729>;
            <D.25728>:
            D.25730 = &MEM[(void *)"_Deleted" + 1B];
            D.25731 = *D.25730;
            D.25732 = (int) D.25731;
            D.25733 = __s2 + 1;
            D.25734 = *D.25733;
            D.25735 = (int) D.25734;
            __result = D.25732 - D.25735;
            D.25736 = __s2_len > 1;
            D.25726 = __result == 0;
            D.25737 = D.25736 & D.25726;
            if (D.25737 != 0) goto <D.25738>; else goto <D.25739>;
            <D.25738>:
            D.25740 = &MEM[(void *)"_Deleted" + 2B];
            D.25741 = *D.25740;
            D.25742 = (int) D.25741;
            D.25743 = __s2 + 2;
            D.25744 = *D.25743;
            D.25745 = (int) D.25744;
            __result = D.25742 - D.25745;
            D.25746 = __s2_len > 2;
            D.25726 = __result == 0;
            D.25747 = D.25746 & D.25726;
            if (D.25747 != 0) goto <D.25748>; else goto <D.25749>;
            <D.25748>:
            D.25750 = &MEM[(void *)"_Deleted" + 3B];
            D.25751 = *D.25750;
            D.25752 = (int) D.25751;
            D.25753 = __s2 + 3;
            D.25754 = *D.25753;
            D.25755 = (int) D.25754;
            __result = D.25752 - D.25755;
            <D.25749>:
            <D.25739>:
            <D.25729>:
          }
          D.20731 = __result;
        }
        iftmp.29 = -D.20731;
        goto <D.25756>;
        <D.25719>:
        D.25757 = mono_field_get_name (field);
        iftmp.29 = __builtin_strcmp (D.25757, "_Deleted");
        <D.25756>:
        D.20732 = iftmp.29;
      }
      if (D.20732 == 0) goto <D.25758>; else goto <D.25759>;
      <D.25758>:
      // predicted unlikely by continue predictor.
      goto <D.20723>;
      <D.25759>:
      <D.25716>:
      D.25708 = field->type;
      D.25760 = D.25708->type;
      D.25761 = (int) D.25760;
      switch (D.25761) <default: <D.20737>, case 8: <D.20733>, case 14: <D.20735>>
      <D.20733>:
      D.25762 = field->offset;
      D.25763 = (sizetype) D.25762;
      D.25764 = this + D.25763;
      D.25765 = *D.25764;
      result = D.25765 ^ result;
      goto <D.20734>;
      <D.20735>:
      {
        struct MonoString * s;

        D.25762 = field->offset;
        D.25763 = (sizetype) D.25762;
        D.25766 = this + D.25763;
        s = *D.25766;
        if (s != 0B) goto <D.25767>; else goto <D.25768>;
        <D.25767>:
        D.25769 = mono_string_hash (s);
        result.30 = (unsigned int) result;
        D.25771 = D.25769 ^ result.30;
        result = (gint32) D.25771;
        <D.25768>:
        goto <D.20734>;
      }
      <D.20737>:
      if (values == 0B) goto <D.25772>; else goto <D.25773>;
      <D.25772>:
      D.25774 = mono_class_num_fields (klass);
      D.25775 = (unsigned int) D.25774;
      D.25776 = D.25775 * 4;
      values = __builtin_alloca (D.25776);
      <D.25773>:
      D.25703 = this->vtable;
      D.25777 = D.25703->domain;
      o = mono_field_get_value_object (D.25777, field, this);
      count.31 = count;
      count = count.31 + 1;
      count.32 = (unsigned int) count.31;
      D.25780 = count.32 * 4;
      D.25781 = values + D.25780;
      *D.25781 = o;
      <D.20734>:
      <D.20723>:
      field = mono_class_get_fields (klass, &iter);
      if (field != 0B) goto <D.20738>; else goto <D.20739>;
      <D.20739>:
      if (values != 0B) goto <D.25782>; else goto <D.25783>;
      <D.25782>:
      {
        int i;

        count.33 = (unsigned int) count;
        D.25785 = mono_defaults.object_class;
        D.25786 = mono_domain_get ();
        D.25787 = mono_array_new (D.25786, D.25785, count.33);
        mono_gc_wbarrier_generic_store (fields, D.25787);
        i = 0;
        goto <D.20743>;
        <D.20742>:
        {
          void * * __p;

          i.34 = (unsigned int) i;
          D.25789 = *fields;
          __p = mono_array_addr_with_size (D.25789, 4, i.34);
          i.35 = (unsigned int) i;
          D.25791 = i.35 * 4;
          D.25792 = values + D.25791;
          D.25793 = *D.25792;
          D.25789 = *fields;
          mono_gc_wbarrier_set_arrayref (D.25789, __p, D.25793);
        }
        i = i + 1;
        <D.20743>:
        if (i < count) goto <D.20742>; else goto <D.20744>;
        <D.20744>:
      }
      goto <D.25794>;
      <D.25783>:
      *fields = 0B;
      <D.25794>:
      D.25707 = result;
      return D.25707;
    }
  finally
    {
      iter = {CLOBBER};
    }
}


ves_icall_System_ValueType_Equals (struct MonoObject * this, struct MonoObject * that, struct MonoArray * * fields)
{
  _Bool D.25797;
  long int D.25798;
  long int D.25799;
  struct MonoVTable * D.25804;
  struct MonoVTable * D.25805;
  MonoBoolean D.25808;
  unsigned char D.25809;
  unsigned char D.25810;
  struct MonoType * D.25813;
  struct MonoType * D.25816;
  unsigned char D.25817;
  gint32 * D.25820;
  int D.25821;
  gint32 * D.25822;
  int D.25823;
  _Bool D.25824;
  struct MonoType * D.25825;
  short unsigned int D.25826;
  int D.25827;
  int D.25828;
  int D.25831;
  int D.20766;
  int iftmp.36;
  int D.20765;
  const char[9] * D.25837;
  unsigned char D.25838;
  int D.25839;
  unsigned char D.25840;
  int D.25841;
  _Bool D.25842;
  _Bool D.25843;
  _Bool D.25844;
  const unsigned char * D.25847;
  unsigned char D.25848;
  int D.25849;
  const unsigned char * D.25850;
  unsigned char D.25851;
  int D.25852;
  _Bool D.25853;
  _Bool D.25854;
  const unsigned char * D.25857;
  unsigned char D.25858;
  int D.25859;
  const unsigned char * D.25860;
  unsigned char D.25861;
  int D.25862;
  _Bool D.25863;
  _Bool D.25864;
  const unsigned char * D.25867;
  unsigned char D.25868;
  int D.25869;
  const unsigned char * D.25870;
  unsigned char D.25871;
  int D.25872;
  const char * D.25874;
  unsigned char D.25877;
  int D.25878;
  int D.25879;
  sizetype D.25880;
  guint8 * D.25881;
  unsigned char D.25882;
  guint8 * D.25883;
  unsigned char D.25884;
  gint16 * D.25887;
  short int D.25888;
  gint16 * D.25889;
  short int D.25890;
  gint32 * D.25893;
  int D.25894;
  gint32 * D.25895;
  int D.25896;
  gint64 * D.25899;
  long long int D.25900;
  gint64 * D.25901;
  long long int D.25902;
  float * D.25905;
  float D.25906;
  float * D.25907;
  float D.25908;
  double * D.25911;
  double D.25912;
  double * D.25913;
  double D.25914;
  struct MonoString * * D.25917;
  struct MonoString * * D.25918;
  _Bool D.25920;
  _Bool D.25921;
  _Bool D.25922;
  int D.25925;
  int D.25926;
  unsigned int D.25929;
  mono_unichar2 * D.25930;
  mono_unichar2 * D.25931;
  int D.25932;
  int D.25937;
  unsigned int D.25938;
  unsigned int D.25939;
  struct MonoDomain * D.25940;
  int count.37;
  unsigned int count.38;
  unsigned int D.25943;
  struct MonoObject * * D.25944;
  int count.39;
  unsigned int count.40;
  unsigned int D.25947;
  struct MonoObject * * D.25948;
  unsigned int count.41;
  struct MonoClass * D.25953;
  struct MonoDomain * D.25954;
  struct MonoArray * D.25955;
  struct MonoArray * D.25956;
  double[0:] * D.25957;
  unsigned int i.42;
  unsigned int D.25959;
  struct MonoObject * * D.25960;
  struct MonoObject * D.25961;
  struct MonoClass * klass;
  struct MonoObject * * values;
  struct MonoObject * o;
  struct MonoClassField * field;
  void * iter;
  int count;

  try
    {
      values = 0B;
      count = 0;
      D.25797 = that == 0B;
      D.25798 = (long int) D.25797;
      D.25799 = __builtin_expect (D.25798, 0);
      if (D.25799 != 0) goto <D.25800>; else goto <D.25801>;
      <D.25800>:
      {
        struct MonoException * ex;

        if (that != 0B) goto <D.25802>; else goto <D.25803>;
        <D.25802>:
        <D.25803>:
        ex = mono_get_exception_argument_null ("that");
        mono_raise_exception (ex);
      }
      <D.25801>:
      D.25804 = this->vtable;
      D.25805 = that->vtable;
      if (D.25804 != D.25805) goto <D.25806>; else goto <D.25807>;
      <D.25806>:
      D.25808 = 0;
      return D.25808;
      <D.25807>:
      D.25804 = this->vtable;
      klass = D.25804->klass;
      D.25809 = BIT_FIELD_REF <*klass, 8, 160>;
      D.25810 = D.25809 & 16;
      if (D.25810 != 0) goto <D.25811>; else goto <D.25812>;
      <D.25811>:
      D.25813 = mono_class_enum_basetype (klass);
      if (D.25813 != 0B) goto <D.25814>; else goto <D.25815>;
      <D.25814>:
      D.25816 = mono_class_enum_basetype (klass);
      D.25817 = D.25816->type;
      if (D.25817 == 8) goto <D.25818>; else goto <D.25819>;
      <D.25818>:
      D.25820 = this + 8;
      D.25821 = *D.25820;
      D.25822 = that + 8;
      D.25823 = *D.25822;
      D.25824 = D.25821 == D.25823;
      D.25808 = (MonoBoolean) D.25824;
      return D.25808;
      <D.25819>:
      <D.25815>:
      <D.25812>:
      *fields = 0B;
      iter = 0B;
      goto <D.20757>;
      <D.20787>:
      D.25825 = field->type;
      D.25826 = D.25825->attrs;
      D.25827 = (int) D.25826;
      D.25828 = D.25827 & 16;
      if (D.25828 != 0) goto <D.25829>; else goto <D.25830>;
      <D.25829>:
      // predicted unlikely by continue predictor.
      goto <D.20757>;
      <D.25830>:
      D.25825 = field->type;
      D.25826 = D.25825->attrs;
      D.25827 = (int) D.25826;
      D.25831 = D.25827 & 1536;
      if (D.25831 != 0) goto <D.25832>; else goto <D.25833>;
      <D.25832>:
      {
        size_t __s1_len;
        size_t __s2_len;

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

          __s2 = mono_field_get_name (field);
          D.25837 = "_Deleted";
          D.25838 = MEM[(const unsigned char *)D.25837];
          D.25839 = (int) D.25838;
          D.25840 = *__s2;
          D.25841 = (int) D.25840;
          __result = D.25839 - D.25841;
          {
            D.25842 = __s2_len != 0;
            D.25843 = __result == 0;
            D.25844 = D.25842 & D.25843;
            if (D.25844 != 0) goto <D.25845>; else goto <D.25846>;
            <D.25845>:
            D.25847 = &MEM[(void *)"_Deleted" + 1B];
            D.25848 = *D.25847;
            D.25849 = (int) D.25848;
            D.25850 = __s2 + 1;
            D.25851 = *D.25850;
            D.25852 = (int) D.25851;
            __result = D.25849 - D.25852;
            D.25853 = __s2_len > 1;
            D.25843 = __result == 0;
            D.25854 = D.25853 & D.25843;
            if (D.25854 != 0) goto <D.25855>; else goto <D.25856>;
            <D.25855>:
            D.25857 = &MEM[(void *)"_Deleted" + 2B];
            D.25858 = *D.25857;
            D.25859 = (int) D.25858;
            D.25860 = __s2 + 2;
            D.25861 = *D.25860;
            D.25862 = (int) D.25861;
            __result = D.25859 - D.25862;
            D.25863 = __s2_len > 2;
            D.25843 = __result == 0;
            D.25864 = D.25863 & D.25843;
            if (D.25864 != 0) goto <D.25865>; else goto <D.25866>;
            <D.25865>:
            D.25867 = &MEM[(void *)"_Deleted" + 3B];
            D.25868 = *D.25867;
            D.25869 = (int) D.25868;
            D.25870 = __s2 + 3;
            D.25871 = *D.25870;
            D.25872 = (int) D.25871;
            __result = D.25869 - D.25872;
            <D.25866>:
            <D.25856>:
            <D.25846>:
          }
          D.20765 = __result;
        }
        iftmp.36 = -D.20765;
        goto <D.25873>;
        <D.25836>:
        D.25874 = mono_field_get_name (field);
        iftmp.36 = __builtin_strcmp (D.25874, "_Deleted");
        <D.25873>:
        D.20766 = iftmp.36;
      }
      if (D.20766 == 0) goto <D.25875>; else goto <D.25876>;
      <D.25875>:
      // predicted unlikely by continue predictor.
      goto <D.20757>;
      <D.25876>:
      <D.25833>:
      D.25825 = field->type;
      D.25877 = D.25825->type;
      D.25878 = (int) D.25877;
      switch (D.25878) <default: <D.20785>, case 2: <D.20769>, case 3: <D.20773>, case 4: <D.20768>, case 5: <D.20767>, case 6: <D.20772>, case 7: <D.20771>, case 8: <D.20775>, case 9: <D.20774>, case 10: <D.20777>, case 11: <D.20776>, case 12: <D.20778>, case 13: <D.20779>, case 14: <D.20780>>
      <D.20767>:
      <D.20768>:
      <D.20769>:
      D.25879 = field->offset;
      D.25880 = (sizetype) D.25879;
      D.25881 = this + D.25880;
      D.25882 = *D.25881;
      D.25879 = field->offset;
      D.25880 = (sizetype) D.25879;
      D.25883 = that + D.25880;
      D.25884 = *D.25883;
      if (D.25882 != D.25884) goto <D.25885>; else goto <D.25886>;
      <D.25885>:
      D.25808 = 0;
      return D.25808;
      <D.25886>:
      goto <D.20770>;
      <D.20771>:
      <D.20772>:
      <D.20773>:
      D.25879 = field->offset;
      D.25880 = (sizetype) D.25879;
      D.25887 = this + D.25880;
      D.25888 = *D.25887;
      D.25879 = field->offset;
      D.25880 = (sizetype) D.25879;
      D.25889 = that + D.25880;
      D.25890 = *D.25889;
      if (D.25888 != D.25890) goto <D.25891>; else goto <D.25892>;
      <D.25891>:
      D.25808 = 0;
      return D.25808;
      <D.25892>:
      goto <D.20770>;
      <D.20774>:
      <D.20775>:
      D.25879 = field->offset;
      D.25880 = (sizetype) D.25879;
      D.25893 = this + D.25880;
      D.25894 = *D.25893;
      D.25879 = field->offset;
      D.25880 = (sizetype) D.25879;
      D.25895 = that + D.25880;
      D.25896 = *D.25895;
      if (D.25894 != D.25896) goto <D.25897>; else goto <D.25898>;
      <D.25897>:
      D.25808 = 0;
      return D.25808;
      <D.25898>:
      goto <D.20770>;
      <D.20776>:
      <D.20777>:
      D.25879 = field->offset;
      D.25880 = (sizetype) D.25879;
      D.25899 = this + D.25880;
      D.25900 = *D.25899;
      D.25879 = field->offset;
      D.25880 = (sizetype) D.25879;
      D.25901 = that + D.25880;
      D.25902 = *D.25901;
      if (D.25900 != D.25902) goto <D.25903>; else goto <D.25904>;
      <D.25903>:
      D.25808 = 0;
      return D.25808;
      <D.25904>:
      goto <D.20770>;
      <D.20778>:
      D.25879 = field->offset;
      D.25880 = (sizetype) D.25879;
      D.25905 = this + D.25880;
      D.25906 = *D.25905;
      D.25879 = field->offset;
      D.25880 = (sizetype) D.25879;
      D.25907 = that + D.25880;
      D.25908 = *D.25907;
      if (D.25906 != D.25908) goto <D.25909>; else goto <D.25910>;
      <D.25909>:
      D.25808 = 0;
      return D.25808;
      <D.25910>:
      goto <D.20770>;
      <D.20779>:
      D.25879 = field->offset;
      D.25880 = (sizetype) D.25879;
      D.25911 = this + D.25880;
      D.25912 = *D.25911;
      D.25879 = field->offset;
      D.25880 = (sizetype) D.25879;
      D.25913 = that + D.25880;
      D.25914 = *D.25913;
      if (D.25912 != D.25914) goto <D.25915>; else goto <D.25916>;
      <D.25915>:
      D.25808 = 0;
      return D.25808;
      <D.25916>:
      goto <D.20770>;
      <D.20780>:
      {
        struct MonoString * s1;
        struct MonoString * s2;
        guint32 s1len;
        guint32 s2len;

        D.25879 = field->offset;
        D.25880 = (sizetype) D.25879;
        D.25917 = this + D.25880;
        s1 = *D.25917;
        D.25879 = field->offset;
        D.25880 = (sizetype) D.25879;
        D.25918 = that + D.25880;
        s2 = *D.25918;
        if (s1 == s2) goto <D.20770>; else goto <D.25919>;
        <D.25919>:
        D.25920 = s1 == 0B;
        D.25921 = s2 == 0B;
        D.25922 = D.25920 | D.25921;
        if (D.25922 != 0) goto <D.25923>; else goto <D.25924>;
        <D.25923>:
        D.25808 = 0;
        return D.25808;
        <D.25924>:
        D.25925 = mono_string_length (s1);
        s1len = (guint32) D.25925;
        D.25926 = mono_string_length (s2);
        s2len = (guint32) D.25926;
        if (s1len != s2len) goto <D.25927>; else goto <D.25928>;
        <D.25927>:
        D.25808 = 0;
        return D.25808;
        <D.25928>:
        D.25929 = s1len * 2;
        D.25930 = mono_string_chars (s2);
        D.25931 = mono_string_chars (s1);
        D.25932 = memcmp (D.25931, D.25930, D.25929);
        if (D.25932 != 0) goto <D.25933>; else goto <D.25934>;
        <D.25933>:
        D.25808 = 0;
        return D.25808;
        <D.25934>:
        goto <D.20770>;
      }
      <D.20785>:
      if (values == 0B) goto <D.25935>; else goto <D.25936>;
      <D.25935>:
      D.25937 = mono_class_num_fields (klass);
      D.25938 = (unsigned int) D.25937;
      D.25939 = D.25938 * 8;
      values = __builtin_alloca (D.25939);
      <D.25936>:
      D.25804 = this->vtable;
      D.25940 = D.25804->domain;
      o = mono_field_get_value_object (D.25940, field, this);
      count.37 = count;
      count = count.37 + 1;
      count.38 = (unsigned int) count.37;
      D.25943 = count.38 * 4;
      D.25944 = values + D.25943;
      *D.25944 = o;
      D.25804 = this->vtable;
      D.25940 = D.25804->domain;
      o = mono_field_get_value_object (D.25940, field, that);
      count.39 = count;
      count = count.39 + 1;
      count.40 = (unsigned int) count.39;
      D.25947 = count.40 * 4;
      D.25948 = values + D.25947;
      *D.25948 = o;
      <D.20770>:
      D.25809 = BIT_FIELD_REF <*klass, 8, 160>;
      D.25810 = D.25809 & 16;
      if (D.25810 != 0) goto <D.20786>; else goto <D.25949>;
      <D.25949>:
      <D.20757>:
      field = mono_class_get_fields (klass, &iter);
      if (field != 0B) goto <D.20787>; else goto <D.20786>;
      <D.20786>:
      if (values != 0B) goto <D.25950>; else goto <D.25951>;
      <D.25950>:
      {
        int i;

        count.41 = (unsigned int) count;
        D.25953 = mono_defaults.object_class;
        D.25954 = mono_domain_get ();
        D.25955 = mono_array_new (D.25954, D.25953, count.41);
        mono_gc_wbarrier_generic_store (fields, D.25955);
        i = 0;
        goto <D.20791>;
        <D.20790>:
        {
          void * * __p;

          D.25956 = *fields;
          D.25957 = &D.25956->vector;
          i.42 = (unsigned int) i;
          D.25959 = i.42 * 4;
          __p = D.25957 + D.25959;
          i.42 = (unsigned int) i;
          D.25959 = i.42 * 4;
          D.25960 = values + D.25959;
          D.25961 = *D.25960;
          D.25956 = *fields;
          mono_gc_wbarrier_set_arrayref (D.25956, __p, D.25961);
        }
        i = i + 1;
        <D.20791>:
        if (i < count) goto <D.20790>; else goto <D.20792>;
        <D.20792>:
        D.25808 = 0;
        return D.25808;
      }
      <D.25951>:
      D.25808 = 1;
      return D.25808;
    }
  finally
    {
      iter = {CLOBBER};
    }
}


mono_TypedReference_ToObjectInternal (struct MonoType * type, void * value, struct MonoClass * klass)
{
  int D.25964;
  struct MonoObject * D.25967;
  struct MonoDomain * D.25968;

  D.25964 = mono_type_is_reference (type);
  if (D.25964 != 0) goto <D.25965>; else goto <D.25966>;
  <D.25965>:
  {
    struct MonoObject * * objp;

    objp = value;
    D.25967 = *objp;
    return D.25967;
  }
  <D.25966>:
  D.25968 = mono_domain_get ();
  D.25967 = mono_value_box (D.25968, klass, value);
  return D.25967;
}


mono_TypedReference_ToObject (struct MonoTypedRef tref)
{
  struct MonoType * D.25970;
  int D.25971;
  struct MonoObject * D.25974;
  void * D.25975;
  struct MonoClass * D.25976;
  struct MonoDomain * D.25977;

  D.25970 = tref.type;
  D.25971 = mono_type_is_reference (D.25970);
  if (D.25971 != 0) goto <D.25972>; else goto <D.25973>;
  <D.25972>:
  {
    struct MonoObject * * objp;

    objp = tref.value;
    D.25974 = *objp;
    return D.25974;
  }
  <D.25973>:
  D.25975 = tref.value;
  D.25976 = tref.klass;
  D.25977 = mono_domain_get ();
  D.25974 = mono_value_box (D.25977, D.25976, D.25975);
  return D.25974;
}


ves_icall_type_is_subtype_of (struct MonoReflectionType * type, struct MonoReflectionType * c, MonoBoolean check_interfaces)
{
  _Bool D.25979;
  long int D.25980;
  long int D.25981;
  struct MonoVTable * D.25984;
  guint32 D.25987;
  struct MonoType * D.25988;
  struct MonoType * D.25989;
  struct MonoClass * * D.25995;
  struct MonoClass * * D.25997;
  unsigned char D.25998;
  unsigned char D.25999;
  struct MonoClass * D.26002;
  _Bool D.26003;
  int D.26004;
  int D.26005;
  struct MonoDomain * domain;
  struct MonoClass * klass;
  struct MonoClass * klassc;

  D.25979 = type == 0B;
  D.25980 = (long int) D.25979;
  D.25981 = __builtin_expect (D.25980, 0);
  if (D.25981 != 0) goto <D.25982>; else goto <D.25983>;
  <D.25982>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "icall.c", 1502, "type != NULL");
  <D.25983>:
  D.25984 = MEM[(struct MonoObject *)type].vtable;
  domain = D.25984->domain;
  if (c == 0B) goto <D.25985>; else goto <D.25986>;
  <D.25985>:
  D.25987 = 0;
  return D.25987;
  <D.25986>:
  D.25988 = type->type;
  klass = mono_class_from_mono_type (D.25988);
  D.25989 = c->type;
  klassc = mono_class_from_mono_type (D.25989);
  if (check_interfaces != 0) goto <D.25990>; else goto <D.25991>;
  <D.25990>:
  mono_class_init_or_throw (klass);
  mono_class_init_or_throw (klassc);
  goto <D.25992>;
  <D.25991>:
  D.25995 = klass->supertypes;
  if (D.25995 == 0B) goto <D.25993>; else goto <D.25996>;
  <D.25996>:
  D.25997 = klassc->supertypes;
  if (D.25997 == 0B) goto <D.25993>; else goto <D.25994>;
  <D.25993>:
  mono_class_setup_supertypes (klass);
  mono_class_setup_supertypes (klassc);
  <D.25994>:
  <D.25992>:
  D.25988 = type->type;
  D.25998 = BIT_FIELD_REF <*D.25988, 8, 56>;
  D.25999 = D.25998 & 64;
  if (D.25999 != 0) goto <D.26000>; else goto <D.26001>;
  <D.26000>:
  D.26002 = mono_defaults.object_class;
  D.26003 = D.26002 == klassc;
  D.25987 = (guint32) D.26003;
  return D.25987;
  <D.26001>:
  D.26004 = (int) check_interfaces;
  D.26005 = mono_class_is_subclass_of (klass, klassc, D.26004);
  D.25987 = (guint32) D.26005;
  return D.25987;
}


mono_class_init_or_throw (struct MonoClass * klass)
{
  int D.26007;
  struct MonoException * D.26010;

  D.26007 = mono_class_init (klass);
  if (D.26007 == 0) goto <D.26008>; else goto <D.26009>;
  <D.26008>:
  D.26010 = mono_class_get_exception_for_failure (klass);
  mono_raise_exception (D.26010);
  <D.26009>:
}


ves_icall_type_is_assignable_from (struct MonoReflectionType * type, struct MonoReflectionType * c)
{
  _Bool D.26011;
  long int D.26012;
  long int D.26013;
  struct MonoVTable * D.26016;
  struct MonoType * D.26017;
  struct MonoType * D.26018;
  unsigned char D.26019;
  unsigned char D.26020;
  unsigned char D.26021;
  unsigned char D.26022;
  guint32 D.26025;
  unsigned char D.26026;
  int D.26029;
  int iftmp.43;
  int D.26035;
  int D.26037;
  int D.26038;
  unsigned char D.26040;
  _Bool D.26041;
  _Bool D.26042;
  _Bool D.26043;
  int iftmp.44;
  unsigned char D.26049;
  unsigned char D.26050;
  struct MonoGenericParam * D.26052;
  short unsigned int D.26053;
  struct MonoGenericParam * D.26054;
  short unsigned int D.26055;
  unsigned char D.26057;
  _Bool D.26058;
  _Bool D.26059;
  _Bool D.26060;
  _Bool D.26063;
  unsigned char D.26064;
  _Bool D.26065;
  _Bool D.26066;
  _Bool D.26067;
  unsigned char D.26070;
  unsigned char D.26071;
  _Bool D.26074;
  unsigned char D.26075;
  unsigned char D.26076;
  unsigned char D.26077;
  _Bool D.26078;
  int D.26079;
  struct MonoDomain * domain;
  struct MonoClass * klass;
  struct MonoClass * klassc;

  D.26011 = type == 0B;
  D.26012 = (long int) D.26011;
  D.26013 = __builtin_expect (D.26012, 0);
  if (D.26013 != 0) goto <D.26014>; else goto <D.26015>;
  <D.26014>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "icall.c", 1555, "type != NULL");
  <D.26015>:
  D.26016 = MEM[(struct MonoObject *)type].vtable;
  domain = D.26016->domain;
  D.26017 = type->type;
  klass = mono_class_from_mono_type (D.26017);
  D.26018 = c->type;
  klassc = mono_class_from_mono_type (D.26018);
  D.26017 = type->type;
  D.26019 = BIT_FIELD_REF <*D.26017, 8, 56>;
  D.26018 = c->type;
  D.26020 = BIT_FIELD_REF <*D.26018, 8, 56>;
  D.26021 = D.26019 ^ D.26020;
  D.26022 = D.26021 & 64;
  if (D.26022 != 0) goto <D.26023>; else goto <D.26024>;
  <D.26023>:
  D.26025 = 0;
  return D.26025;
  <D.26024>:
  D.26017 = type->type;
  D.26019 = BIT_FIELD_REF <*D.26017, 8, 56>;
  D.26026 = D.26019 & 64;
  if (D.26026 != 0) goto <D.26027>; else goto <D.26028>;
  <D.26027>:
  {
    struct MonoType * t;
    struct MonoType * ot;

    D.26017 = type->type;
    t = mono_type_get_underlying_type_ignore_byref (D.26017);
    D.26018 = c->type;
    ot = mono_type_get_underlying_type_ignore_byref (D.26018);
    klass = mono_class_from_mono_type (t);
    klassc = mono_class_from_mono_type (ot);
    D.26029 = mono_type_is_primitive (t);
    if (D.26029 != 0) goto <D.26030>; else goto <D.26031>;
    <D.26030>:
    D.26035 = mono_type_is_primitive (ot);
    if (D.26035 != 0) goto <D.26036>; else goto <D.26033>;
    <D.26036>:
    D.26037 = klass->instance_size;
    D.26038 = klassc->instance_size;
    if (D.26037 == D.26038) goto <D.26039>; else goto <D.26033>;
    <D.26039>:
    iftmp.43 = 1;
    goto <D.26034>;
    <D.26033>:
    iftmp.43 = 0;
    <D.26034>:
    D.26025 = (guint32) iftmp.43;
    return D.26025;
    <D.26031>:
    D.26040 = t->type;
    D.26041 = D.26040 == 19;
    D.26042 = D.26040 == 30;
    D.26043 = D.26041 | D.26042;
    if (D.26043 != 0) goto <D.26044>; else goto <D.26045>;
    <D.26044>:
    D.26049 = t->type;
    D.26050 = ot->type;
    if (D.26049 == D.26050) goto <D.26051>; else goto <D.26047>;
    <D.26051>:
    D.26052 = t->data.generic_param;
    D.26053 = D.26052->num;
    D.26054 = ot->data.generic_param;
    D.26055 = D.26054->num;
    if (D.26053 == D.26055) goto <D.26056>; else goto <D.26047>;
    <D.26056>:
    iftmp.44 = 1;
    goto <D.26048>;
    <D.26047>:
    iftmp.44 = 0;
    <D.26048>:
    D.26025 = (guint32) iftmp.44;
    return D.26025;
    <D.26045>:
    D.26057 = t->type;
    D.26058 = D.26057 == 15;
    D.26059 = D.26057 == 27;
    D.26060 = D.26058 | D.26059;
    if (D.26060 != 0) goto <D.26061>; else goto <D.26062>;
    <D.26061>:
    D.26049 = t->type;
    D.26050 = ot->type;
    D.26063 = D.26049 == D.26050;
    D.26025 = (guint32) D.26063;
    return D.26025;
    <D.26062>:
    D.26064 = ot->type;
    D.26065 = D.26064 == 19;
    D.26066 = D.26064 == 30;
    D.26067 = D.26065 | D.26066;
    if (D.26067 != 0) goto <D.26068>; else goto <D.26069>;
    <D.26068>:
    D.26025 = 0;
    return D.26025;
    <D.26069>:
    D.26070 = BIT_FIELD_REF <*klass, 8, 160>;
    D.26071 = D.26070 & 8;
    if (D.26071 != 0) goto <D.26072>; else goto <D.26073>;
    <D.26072>:
    D.26074 = klass == klassc;
    D.26025 = (guint32) D.26074;
    return D.26025;
    <D.26073>:
    D.26070 = BIT_FIELD_REF <*klass, 8, 160>;
    D.26075 = BIT_FIELD_REF <*klassc, 8, 160>;
    D.26076 = D.26070 ^ D.26075;
    D.26077 = D.26076 & 8;
    D.26078 = D.26077 == 0;
    D.26025 = (guint32) D.26078;
    return D.26025;
  }
  <D.26028>:
  D.26079 = mono_class_is_assignable_from (klass, klassc);
  D.26025 = (guint32) D.26079;
  return D.26025;
}


mono_type_get_underlying_type_ignore_byref (struct MonoType * type)
{
  unsigned char D.26081;
  struct MonoClass * D.26084;
  unsigned char D.26085;
  unsigned char D.26086;
  struct MonoType * D.26089;
  struct MonoGenericClass * D.26092;
  struct MonoClass * D.26093;
  unsigned char D.26094;
  unsigned char D.26095;

  D.26081 = type->type;
  if (D.26081 == 17) goto <D.26082>; else goto <D.26083>;
  <D.26082>:
  D.26084 = type->data.klass;
  D.26085 = BIT_FIELD_REF <*D.26084, 8, 160>;
  D.26086 = D.26085 & 16;
  if (D.26086 != 0) goto <D.26087>; else goto <D.26088>;
  <D.26087>:
  D.26084 = type->data.klass;
  D.26089 = mono_class_enum_basetype (D.26084);
  return D.26089;
  <D.26088>:
  <D.26083>:
  D.26081 = type->type;
  if (D.26081 == 21) goto <D.26090>; else goto <D.26091>;
  <D.26090>:
  D.26092 = type->data.generic_class;
  D.26093 = D.26092->container_class;
  D.26094 = BIT_FIELD_REF <*D.26093, 8, 160>;
  D.26095 = D.26094 & 16;
  if (D.26095 != 0) goto <D.26096>; else goto <D.26097>;
  <D.26096>:
  D.26092 = type->data.generic_class;
  D.26093 = D.26092->container_class;
  D.26089 = mono_class_enum_basetype (D.26093);
  return D.26089;
  <D.26097>:
  <D.26091>:
  D.26089 = type;
  return D.26089;
}


mono_type_is_primitive (struct MonoType * type)
{
  gboolean D.26099;
  int iftmp.45;
  unsigned char D.26104;
  unsigned char D.26105;
  _Bool D.26106;
  _Bool D.26107;
  _Bool D.26108;
  unsigned char D.26110;

  D.26104 = type->type;
  D.26105 = D.26104 + 254;
  D.26106 = D.26105 <= 11;
  D.26107 = D.26104 == 24;
  D.26108 = D.26106 | D.26107;
  if (D.26108 != 0) goto <D.26101>; else goto <D.26109>;
  <D.26109>:
  D.26110 = type->type;
  if (D.26110 == 25) goto <D.26101>; else goto <D.26102>;
  <D.26101>:
  iftmp.45 = 1;
  goto <D.26103>;
  <D.26102>:
  iftmp.45 = 0;
  <D.26103>:
  D.26099 = iftmp.45;
  return D.26099;
}


ves_icall_Type_make_byref_type (struct MonoReflectionType * type)
{
  struct MonoType * D.26112;
  struct MonoReflectionType * D.26113;
  struct MonoType * D.26114;
  struct MonoVTable * D.26115;
  struct MonoDomain * D.26116;
  struct MonoClass * klass;

  D.26112 = type->type;
  klass = mono_class_from_mono_type (D.26112);
  mono_class_init_or_throw (klass);
  check_for_invalid_type (klass);
  D.26114 = &klass->this_arg;
  D.26115 = MEM[(struct MonoObject *)type].vtable;
  D.26116 = D.26115->domain;
  D.26113 = mono_type_get_object (D.26116, D.26114);
  return D.26113;
}


check_for_invalid_type (struct MonoClass * klass)
{
  unsigned char D.26118;
  struct MonoDomain * D.26121;
  struct MonoException * D.26122;
  char * name;
  struct MonoString * str;

  D.26118 = klass->byval_arg.type;
  if (D.26118 != 22) goto <D.26119>; else goto <D.26120>;
  <D.26119>:
  return;
  <D.26120>:
  name = mono_type_get_full_name (klass);
  D.26121 = mono_domain_get ();
  str = mono_string_new (D.26121, name);
  monoeg_g_free (name);
  D.26122 = mono_get_exception_type_load (str, 0B);
  mono_raise_exception (D.26122);
}


ves_icall_Type_make_array_type (struct MonoReflectionType * type, int rank)
{
  struct MonoType * D.26124;
  unsigned int rank.46;
  struct MonoReflectionType * D.26129;
  struct MonoType * D.26130;
  struct MonoVTable * D.26131;
  struct MonoDomain * D.26132;
  struct MonoClass * klass;
  struct MonoClass * aklass;

  D.26124 = type->type;
  klass = mono_class_from_mono_type (D.26124);
  check_for_invalid_type (klass);
  if (rank == 0) goto <D.26125>; else goto <D.26126>;
  <D.26125>:
  aklass = mono_array_class_get (klass, 1);
  goto <D.26127>;
  <D.26126>:
  rank.46 = (unsigned int) rank;
  aklass = mono_bounded_array_class_get (klass, rank.46, 1);
  <D.26127>:
  D.26130 = &aklass->byval_arg;
  D.26131 = MEM[(struct MonoObject *)type].vtable;
  D.26132 = D.26131->domain;
  D.26129 = mono_type_get_object (D.26132, D.26130);
  return D.26129;
}


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

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

    e = 0B;
    if (throwOnError != 0) goto <D.26137>; else goto <D.26138>;
    <D.26137>:
    e = mono_get_exception_type_load (name, 0B);
    <D.26138>:
    mono_loader_clear_error ();
    if (e != 0B) goto <D.26139>; else goto <D.26140>;
    <D.26139>:
    mono_raise_exception (e);
    <D.26140>:
  }
  <D.26136>:
  D.26141 = type;
  return D.26141;
}


type_from_name (const char * str, MonoBoolean ignoreCase)
{
  int D.26143;
  struct MonoReflectionType * D.26146;
  const char * D.26147;
  struct MonoMethod * dest.47;
  struct MonoClass * D.26156;
  struct MonoImage * D.26157;
  int D.26161;
  struct MonoImage * D.26162;
  _Bool D.26167;
  _Bool D.26168;
  _Bool D.26169;
  int type_resolve.48;
  struct MonoDomain * D.26177;
  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.26143 = mono_reflection_parse_type (temp_str, &info);
      if (D.26143 == 0) goto <D.26144>; else goto <D.26145>;
      <D.26144>:
      mono_reflection_free_type_info (&info);
      monoeg_g_free (temp_str);
      D.26146 = 0B;
      return D.26146;
      <D.26145>:
      D.26147 = info.assembly.name;
      if (D.26147 != 0B) goto <D.26148>; else goto <D.26149>;
      <D.26148>:
      assembly = mono_assembly_load (&info.assembly, 0B, 0B);
      goto <D.26150>;
      <D.26149>:
      {
        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.47 = dest;
            if (dest.47 == 0B) goto <D.26152>; else goto <D.26153>;
            <D.26152>:
            dest = m;
            <D.26153>:
            dest.47 = dest;
            if (dest.47 != 0B) goto <D.26154>; else goto <D.26155>;
            <D.26154>:
            dest.47 = dest;
            D.26156 = dest.47->klass;
            D.26157 = D.26156->image;
            assembly = D.26157->assembly;
            type_resolve = 1;
            goto <D.26158>;
            <D.26155>:
            monoeg_g_log (0B, 16, "icall.c:1303:");
            <D.26158>:
          }
        finally
          {
            dest = {CLOBBER};
          }
      }
      <D.26150>:
      if (assembly != 0B) goto <D.26159>; else goto <D.26160>;
      <D.26159>:
      D.26161 = (int) ignoreCase;
      D.26162 = assembly->image;
      type = mono_reflection_get_type (D.26162, &info, D.26161, &type_resolve);
      <D.26160>:
      D.26147 = info.assembly.name;
      if (D.26147 == 0B) goto <D.26163>; else goto <D.26164>;
      <D.26163>:
      if (type == 0B) goto <D.26165>; else goto <D.26166>;
      <D.26165>:
      D.26161 = (int) ignoreCase;
      type = mono_reflection_get_type (0B, &info, D.26161, &type_resolve);
      <D.26166>:
      <D.26164>:
      D.26167 = assembly != 0B;
      D.26168 = type == 0B;
      D.26169 = D.26167 & D.26168;
      if (D.26169 != 0) goto <D.26170>; else goto <D.26171>;
      <D.26170>:
      type_resolve.48 = type_resolve;
      if (type_resolve.48 != 0) goto <D.26173>; else goto <D.26174>;
      <D.26173>:
      type_resolve = 0;
      D.26161 = (int) ignoreCase;
      D.26162 = assembly->image;
      type = mono_reflection_get_type (D.26162, &info, D.26161, &type_resolve);
      <D.26174>:
      <D.26171>:
      mono_reflection_free_type_info (&info);
      monoeg_g_free (temp_str);
      if (type == 0B) goto <D.26175>; else goto <D.26176>;
      <D.26175>:
      D.26146 = 0B;
      return D.26146;
      <D.26176>:
      D.26177 = mono_domain_get ();
      D.26146 = mono_type_get_object (D.26177, type);
      return D.26146;
    }
  finally
    {
      info = {CLOBBER};
      type_resolve = {CLOBBER};
    }
}


get_caller_no_reflection (struct MonoMethod * m, gint32 no, gint32 ilo, gboolean managed, void * data)
{
  gboolean D.26182;
  unsigned char D.26183;
  unsigned char D.26184;
  struct MonoClass * D.26187;
  struct MonoImage * D.26188;
  struct MonoImage * D.26189;
  int D.20865;
  int iftmp.49;
  int D.20864;
  const char[18] * D.26195;
  unsigned char D.26196;
  int D.26197;
  unsigned char D.26198;
  int D.26199;
  _Bool D.26200;
  _Bool D.26201;
  _Bool D.26202;
  const unsigned char * D.26205;
  unsigned char D.26206;
  int D.26207;
  const unsigned char * D.26208;
  unsigned char D.26209;
  int D.26210;
  _Bool D.26211;
  _Bool D.26212;
  const unsigned char * D.26215;
  unsigned char D.26216;
  int D.26217;
  const unsigned char * D.26218;
  unsigned char D.26219;
  int D.26220;
  _Bool D.26221;
  _Bool D.26222;
  const unsigned char * D.26225;
  unsigned char D.26226;
  int D.26227;
  const unsigned char * D.26228;
  unsigned char D.26229;
  int D.26230;
  const char * D.26232;
  struct MonoMethod * D.26235;
  struct MonoMethod * * dest;

  dest = data;
  if (managed == 0) goto <D.26180>; else goto <D.26181>;
  <D.26180>:
  D.26182 = 0;
  return D.26182;
  <D.26181>:
  D.26183 = BIT_FIELD_REF <*m, 8, 160>;
  D.26184 = D.26183 & 124;
  if (D.26184 != 0) goto <D.26185>; else goto <D.26186>;
  <D.26185>:
  D.26182 = 0;
  return D.26182;
  <D.26186>:
  D.26187 = m->klass;
  D.26188 = D.26187->image;
  D.26189 = mono_defaults.corlib;
  if (D.26188 == D.26189) goto <D.26190>; else goto <D.26191>;
  <D.26190>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      D.26187 = m->klass;
      __s2 = D.26187->name_space;
      D.26195 = "System.Reflection";
      D.26196 = MEM[(const unsigned char *)D.26195];
      D.26197 = (int) D.26196;
      D.26198 = *__s2;
      D.26199 = (int) D.26198;
      __result = D.26197 - D.26199;
      {
        D.26200 = __s2_len != 0;
        D.26201 = __result == 0;
        D.26202 = D.26200 & D.26201;
        if (D.26202 != 0) goto <D.26203>; else goto <D.26204>;
        <D.26203>:
        D.26205 = &MEM[(void *)"System.Reflection" + 1B];
        D.26206 = *D.26205;
        D.26207 = (int) D.26206;
        D.26208 = __s2 + 1;
        D.26209 = *D.26208;
        D.26210 = (int) D.26209;
        __result = D.26207 - D.26210;
        D.26211 = __s2_len > 1;
        D.26201 = __result == 0;
        D.26212 = D.26211 & D.26201;
        if (D.26212 != 0) goto <D.26213>; else goto <D.26214>;
        <D.26213>:
        D.26215 = &MEM[(void *)"System.Reflection" + 2B];
        D.26216 = *D.26215;
        D.26217 = (int) D.26216;
        D.26218 = __s2 + 2;
        D.26219 = *D.26218;
        D.26220 = (int) D.26219;
        __result = D.26217 - D.26220;
        D.26221 = __s2_len > 2;
        D.26201 = __result == 0;
        D.26222 = D.26221 & D.26201;
        if (D.26222 != 0) goto <D.26223>; else goto <D.26224>;
        <D.26223>:
        D.26225 = &MEM[(void *)"System.Reflection" + 3B];
        D.26226 = *D.26225;
        D.26227 = (int) D.26226;
        D.26228 = __s2 + 3;
        D.26229 = *D.26228;
        D.26230 = (int) D.26229;
        __result = D.26227 - D.26230;
        <D.26224>:
        <D.26214>:
        <D.26204>:
      }
      D.20864 = __result;
    }
    iftmp.49 = -D.20864;
    goto <D.26231>;
    <D.26194>:
    D.26187 = m->klass;
    D.26232 = D.26187->name_space;
    iftmp.49 = __builtin_strcmp (D.26232, "System.Reflection");
    <D.26231>:
    D.20865 = iftmp.49;
  }
  if (D.20865 == 0) goto <D.26233>; else goto <D.26234>;
  <D.26233>:
  D.26182 = 0;
  return D.26182;
  <D.26234>:
  <D.26191>:
  D.26235 = *dest;
  if (D.26235 == m) goto <D.26236>; else goto <D.26237>;
  <D.26236>:
  *dest = 0B;
  D.26182 = 0;
  return D.26182;
  <D.26237>:
  D.26235 = *dest;
  if (D.26235 == 0B) goto <D.26238>; else goto <D.26239>;
  <D.26238>:
  *dest = m;
  D.26182 = 1;
  return D.26182;
  <D.26239>:
  D.26182 = 0;
  return D.26182;
}


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

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


ves_icall_Type_get_IsGenericTypeDefinition (struct MonoReflectionType * type)
{
  struct MonoVTable * D.26247;
  struct MonoClass * D.26248;
  struct MonoImage * D.26249;
  struct MonoImage * D.26250;
  struct MonoType * D.26252;
  gboolean D.26253;
  unsigned char D.26254;
  unsigned char D.26255;
  struct MonoGenericContainer * D.26258;
  _Bool D.26259;
  struct MonoClass * klass;

  if (type != 0B) goto <D.26245>; else goto <D.26246>;
  <D.26245>:
  D.26247 = MEM[(struct MonoObject *)type].vtable;
  D.26248 = D.26247->klass;
  D.26249 = D.26248->image;
  D.26250 = mono_defaults.corlib;
  if (D.26249 != D.26250) goto <D.26243>; else goto <D.26251>;
  <D.26251>:
  D.26252 = type->type;
  if (D.26252 == 0B) goto <D.26243>; else goto <D.26244>;
  <D.26243>:
  D.26253 = 0;
  return D.26253;
  <D.26244>:
  <D.26246>:
  D.26252 = type->type;
  D.26254 = BIT_FIELD_REF <*D.26252, 8, 56>;
  D.26255 = D.26254 & 64;
  if (D.26255 != 0) goto <D.26256>; else goto <D.26257>;
  <D.26256>:
  D.26253 = 0;
  return D.26253;
  <D.26257>:
  D.26252 = type->type;
  klass = mono_class_from_mono_type (D.26252);
  D.26258 = klass->generic_container;
  D.26259 = D.26258 != 0B;
  D.26253 = (gboolean) D.26259;
  return D.26253;
}


ves_icall_Type_get_IsGenericType (struct MonoReflectionType * type)
{
  struct MonoVTable * D.26265;
  struct MonoClass * D.26266;
  struct MonoImage * D.26267;
  struct MonoImage * D.26268;
  struct MonoType * D.26270;
  gboolean D.26271;
  unsigned char D.26272;
  unsigned char D.26273;
  int iftmp.50;
  struct MonoGenericClass * D.26280;
  struct MonoGenericContainer * D.26282;
  struct MonoClass * klass;

  if (type != 0B) goto <D.26263>; else goto <D.26264>;
  <D.26263>:
  D.26265 = MEM[(struct MonoObject *)type].vtable;
  D.26266 = D.26265->klass;
  D.26267 = D.26266->image;
  D.26268 = mono_defaults.corlib;
  if (D.26267 != D.26268) goto <D.26261>; else goto <D.26269>;
  <D.26269>:
  D.26270 = type->type;
  if (D.26270 == 0B) goto <D.26261>; else goto <D.26262>;
  <D.26261>:
  D.26271 = 0;
  return D.26271;
  <D.26262>:
  <D.26264>:
  D.26270 = type->type;
  D.26272 = BIT_FIELD_REF <*D.26270, 8, 56>;
  D.26273 = D.26272 & 64;
  if (D.26273 != 0) goto <D.26274>; else goto <D.26275>;
  <D.26274>:
  D.26271 = 0;
  return D.26271;
  <D.26275>:
  D.26270 = type->type;
  klass = mono_class_from_mono_type (D.26270);
  D.26280 = klass->generic_class;
  if (D.26280 != 0B) goto <D.26277>; else goto <D.26281>;
  <D.26281>:
  D.26282 = klass->generic_container;
  if (D.26282 != 0B) goto <D.26277>; else goto <D.26278>;
  <D.26277>:
  iftmp.50 = 1;
  goto <D.26279>;
  <D.26278>:
  iftmp.50 = 0;
  <D.26279>:
  D.26271 = iftmp.50;
  return D.26271;
}


ves_icall_Type_get_IsGenericInstance (struct MonoReflectionType * type)
{
  struct MonoType * D.26284;
  unsigned char D.26285;
  unsigned char D.26286;
  gboolean D.26289;
  struct MonoGenericClass * D.26290;
  _Bool D.26291;
  struct MonoClass * klass;

  D.26284 = type->type;
  D.26285 = BIT_FIELD_REF <*D.26284, 8, 56>;
  D.26286 = D.26285 & 64;
  if (D.26286 != 0) goto <D.26287>; else goto <D.26288>;
  <D.26287>:
  D.26289 = 0;
  return D.26289;
  <D.26288>:
  D.26284 = type->type;
  klass = mono_class_from_mono_type (D.26284);
  D.26290 = klass->generic_class;
  D.26291 = D.26290 != 0B;
  D.26289 = (gboolean) D.26291;
  return D.26289;
}


ves_icall_Type_MakePointerType (struct MonoReflectionType * type)
{
  struct MonoType * D.26293;
  struct MonoReflectionType * D.26294;
  struct MonoType * D.26295;
  struct MonoVTable * D.26296;
  struct MonoDomain * D.26297;
  struct MonoClass * klass;
  struct MonoClass * pklass;

  D.26293 = type->type;
  klass = mono_class_from_mono_type (D.26293);
  mono_class_init_or_throw (klass);
  check_for_invalid_type (klass);
  D.26293 = type->type;
  pklass = mono_ptr_class_get (D.26293);
  D.26295 = &pklass->byval_arg;
  D.26296 = MEM[(struct MonoObject *)type].vtable;
  D.26297 = D.26296->domain;
  D.26294 = mono_type_get_object (D.26297, D.26295);
  return D.26294;
}


ves_icall_Type_MakeGenericType (struct MonoReflectionType * type, struct MonoArray * type_array)
{
  int iftmp.51;
  struct MonoVTable * D.26304;
  struct MonoClass * D.26305;
  struct MonoImage * D.26306;
  struct MonoImage * D.26307;
  struct MonoType * D.26309;
  _Bool D.26310;
  long int D.26311;
  long int D.26312;
  struct MonoClass * D.26315;
  unsigned int D.26316;
  unsigned int count.52;
  unsigned int D.26318;
  unsigned int i.53;
  char * D.26320;
  unsigned int i.54;
  unsigned int D.26322;
  struct MonoType * * D.26323;
  struct MonoType * D.26324;
  struct MonoReflectionType * D.26327;
  struct MonoGenericClass * D.26328;
  int D.26331;
  struct MonoException * D.26334;
  struct MonoDomain * D.26335;
  struct MonoClass * class;
  struct MonoType * geninst;
  struct MonoType * * types;
  int i;
  int count;

  if (type != 0B) goto <D.26303>; else goto <D.26300>;
  <D.26303>:
  D.26304 = MEM[(struct MonoObject *)type].vtable;
  D.26305 = D.26304->klass;
  D.26306 = D.26305->image;
  D.26307 = mono_defaults.corlib;
  if (D.26306 != D.26307) goto <D.26301>; else goto <D.26308>;
  <D.26308>:
  D.26309 = type->type;
  if (D.26309 == 0B) goto <D.26301>; else goto <D.26300>;
  <D.26301>:
  iftmp.51 = 1;
  goto <D.26302>;
  <D.26300>:
  iftmp.51 = 0;
  <D.26302>:
  D.26310 = iftmp.51 != 0;
  D.26311 = (long int) D.26310;
  D.26312 = __builtin_expect (D.26311, 0);
  if (D.26312 != 0) goto <D.26313>; else goto <D.26314>;
  <D.26313>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "icall.c", 2404, "IS_MONOTYPE (type)");
  <D.26314>:
  D.26309 = type->type;
  D.26315 = mono_class_from_mono_type (D.26309);
  mono_class_init_or_throw (D.26315);
  D.26316 = mono_array_length (type_array);
  count = (int) D.26316;
  count.52 = (unsigned int) count;
  D.26318 = count.52 * 4;
  types = monoeg_malloc0 (D.26318);
  i = 0;
  goto <D.21366>;
  <D.21365>:
  {
    struct MonoReflectionType * t;

    i.53 = (unsigned int) i;
    D.26320 = mono_array_addr_with_size (type_array, 4, i.53);
    t = MEM[(void * *)D.26320];
    i.54 = (unsigned int) i;
    D.26322 = i.54 * 4;
    D.26323 = types + D.26322;
    D.26324 = t->type;
    *D.26323 = D.26324;
  }
  i = i + 1;
  <D.21366>:
  if (i < count) goto <D.21365>; else goto <D.21367>;
  <D.21367>:
  geninst = mono_reflection_bind_generic_parameters (type, count, types);
  monoeg_g_free (types);
  if (geninst == 0B) goto <D.26325>; else goto <D.26326>;
  <D.26325>:
  D.26327 = 0B;
  return D.26327;
  <D.26326>:
  class = mono_class_from_mono_type (geninst);
  D.26328 = class->generic_class;
  if (D.26328 != 0B) goto <D.26329>; else goto <D.26330>;
  <D.26329>:
  D.26331 = mono_verifier_class_is_valid_generic_instantiation (class);
  if (D.26331 == 0) goto <D.26332>; else goto <D.26333>;
  <D.26332>:
  D.26334 = mono_get_exception_argument ("typeArguments", "Invalid generic arguments");
  mono_raise_exception (D.26334);
  <D.26333>:
  <D.26330>:
  D.26304 = MEM[(struct MonoObject *)type].vtable;
  D.26335 = D.26304->domain;
  D.26327 = mono_type_get_object (D.26335, geninst);
  return D.26327;
}


ves_icall_type_IsInstanceOfType (struct MonoReflectionType * type, struct MonoObject * obj)
{
  struct MonoType * D.26337;
  guint32 D.26338;
  struct MonoObject * D.26339;
  _Bool D.26340;
  struct MonoClass * klass;

  D.26337 = type->type;
  klass = mono_class_from_mono_type (D.26337);
  mono_class_init_or_throw (klass);
  D.26339 = mono_object_isinst (obj, klass);
  D.26340 = D.26339 != 0B;
  D.26338 = (guint32) D.26340;
  return D.26338;
}


ves_icall_Type_IsArrayImpl (struct MonoReflectionType * t)
{
  int iftmp.55;
  unsigned char D.26345;
  unsigned char D.26346;
  unsigned char D.26348;
  _Bool D.26349;
  _Bool D.26350;
  _Bool D.26351;
  MonoBoolean D.26353;
  struct MonoType * type;
  MonoBoolean res;

  type = t->type;
  D.26345 = BIT_FIELD_REF <*type, 8, 56>;
  D.26346 = D.26345 & 64;
  if (D.26346 == 0) goto <D.26347>; else goto <D.26343>;
  <D.26347>:
  D.26348 = type->type;
  D.26349 = D.26348 == 20;
  D.26350 = D.26348 == 29;
  D.26351 = D.26349 | D.26350;
  if (D.26351 != 0) goto <D.26352>; else goto <D.26343>;
  <D.26352>:
  iftmp.55 = 1;
  goto <D.26344>;
  <D.26343>:
  iftmp.55 = 0;
  <D.26344>:
  res = (MonoBoolean) iftmp.55;
  D.26353 = res;
  return D.26353;
}


ves_icall_type_GetTypeCodeInternal (struct MonoReflectionType * type)
{
  struct MonoType * D.26355;
  unsigned char D.26356;
  unsigned char D.26357;
  unsigned char D.26358;
  guint32 D.26361;
  unsigned char D.26362;
  unsigned char D.26363;
  struct MonoType * D.26366;
  unsigned char D.26367;
  struct MonoImage * D.26368;
  int D.26369;
  int D.20944;
  int iftmp.56;
  int D.20943;
  const char[7] * D.26375;
  unsigned char D.26376;
  int D.26377;
  unsigned char D.26378;
  int D.26379;
  _Bool D.26380;
  _Bool D.26381;
  _Bool D.26382;
  const unsigned char * D.26385;
  unsigned char D.26386;
  int D.26387;
  const unsigned char * D.26388;
  unsigned char D.26389;
  int D.26390;
  _Bool D.26391;
  _Bool D.26392;
  const unsigned char * D.26395;
  unsigned char D.26396;
  int D.26397;
  const unsigned char * D.26398;
  unsigned char D.26399;
  int D.26400;
  _Bool D.26401;
  _Bool D.26402;
  const unsigned char * D.26405;
  unsigned char D.26406;
  int D.26407;
  const unsigned char * D.26408;
  unsigned char D.26409;
  int D.26410;
  const char * D.26412;
  int D.20953;
  int iftmp.57;
  int D.20952;
  const char[8] * D.26418;
  unsigned char D.26419;
  int D.26420;
  unsigned char D.26421;
  int D.26422;
  _Bool D.26423;
  _Bool D.26424;
  _Bool D.26425;
  const unsigned char * D.26428;
  unsigned char D.26429;
  int D.26430;
  const unsigned char * D.26431;
  unsigned char D.26432;
  int D.26433;
  _Bool D.26434;
  _Bool D.26435;
  const unsigned char * D.26438;
  unsigned char D.26439;
  int D.26440;
  const unsigned char * D.26441;
  unsigned char D.26442;
  int D.26443;
  _Bool D.26444;
  _Bool D.26445;
  const unsigned char * D.26448;
  unsigned char D.26449;
  int D.26450;
  const unsigned char * D.26451;
  unsigned char D.26452;
  int D.26453;
  const char * D.26455;
  int D.20962;
  int iftmp.58;
  int D.20961;
  const char[9] * D.26461;
  unsigned char D.26462;
  int D.26463;
  unsigned char D.26464;
  int D.26465;
  _Bool D.26466;
  _Bool D.26467;
  _Bool D.26468;
  const unsigned char * D.26471;
  unsigned char D.26472;
  int D.26473;
  const unsigned char * D.26474;
  unsigned char D.26475;
  int D.26476;
  _Bool D.26477;
  _Bool D.26478;
  const unsigned char * D.26481;
  unsigned char D.26482;
  int D.26483;
  const unsigned char * D.26484;
  unsigned char D.26485;
  int D.26486;
  _Bool D.26487;
  _Bool D.26488;
  const unsigned char * D.26491;
  unsigned char D.26492;
  int D.26493;
  const unsigned char * D.26494;
  unsigned char D.26495;
  int D.26496;
  struct MonoImage * D.26500;
  struct MonoImage * D.26501;
  int D.20980;
  int iftmp.59;
  int D.20979;
  unsigned char D.26507;
  int D.26508;
  _Bool D.26509;
  _Bool D.26510;
  _Bool D.26511;
  const unsigned char * D.26514;
  unsigned char D.26515;
  int D.26516;
  _Bool D.26517;
  _Bool D.26518;
  const unsigned char * D.26521;
  unsigned char D.26522;
  int D.26523;
  _Bool D.26524;
  _Bool D.26525;
  const unsigned char * D.26528;
  unsigned char D.26529;
  int D.26530;
  const char * D.26532;
  int D.20989;
  int iftmp.60;
  int D.20988;
  const char[7] * D.26538;
  unsigned char D.26539;
  int D.26540;
  unsigned char D.26541;
  int D.26542;
  _Bool D.26543;
  _Bool D.26544;
  _Bool D.26545;
  const unsigned char * D.26548;
  unsigned char D.26549;
  int D.26550;
  const unsigned char * D.26551;
  unsigned char D.26552;
  int D.26553;
  _Bool D.26554;
  _Bool D.26555;
  const unsigned char * D.26558;
  unsigned char D.26559;
  int D.26560;
  const unsigned char * D.26561;
  unsigned char D.26562;
  int D.26563;
  _Bool D.26564;
  _Bool D.26565;
  const unsigned char * D.26568;
  unsigned char D.26569;
  int D.26570;
  const unsigned char * D.26571;
  unsigned char D.26572;
  int D.26573;
  const char * D.26575;
  int t;
  void handle_enum = <<< error >>>;

  D.26355 = type->type;
  D.26356 = D.26355->type;
  t = (int) D.26356;
  D.26355 = type->type;
  D.26357 = BIT_FIELD_REF <*D.26355, 8, 56>;
  D.26358 = D.26357 & 64;
  if (D.26358 != 0) goto <D.26359>; else goto <D.26360>;
  <D.26359>:
  D.26361 = 1;
  return D.26361;
  <D.26360>:
  handle_enum:
  switch (t) <default: <D.20991>, case 1: <D.20918>, case 2: <D.20919>, case 3: <D.20924>, case 4: <D.20921>, case 5: <D.20920>, case 6: <D.20923>, case 7: <D.20922>, case 8: <D.20929>, case 9: <D.20928>, case 10: <D.20931>, case 11: <D.20930>, case 12: <D.20932>, case 13: <D.20933>, case 14: <D.20963>, case 15: <D.20925>, case 17: <D.20934>, case 18: <D.20970>, case 19: <D.20967>, case 20: <D.20965>, case 21: <D.20990>, case 22: <D.20969>, case 24: <D.20927>, case 25: <D.20926>, case 28: <D.20966>, case 29: <D.20964>, case 30: <D.20968>>
  <D.20918>:
  D.26361 = 1;
  return D.26361;
  <D.20919>:
  D.26361 = 3;
  return D.26361;
  <D.20920>:
  D.26361 = 6;
  return D.26361;
  <D.20921>:
  D.26361 = 5;
  return D.26361;
  <D.20922>:
  D.26361 = 8;
  return D.26361;
  <D.20923>:
  D.26361 = 7;
  return D.26361;
  <D.20924>:
  D.26361 = 4;
  return D.26361;
  <D.20925>:
  <D.20926>:
  <D.20927>:
  D.26361 = 1;
  return D.26361;
  <D.20928>:
  D.26361 = 10;
  return D.26361;
  <D.20929>:
  D.26361 = 9;
  return D.26361;
  <D.20930>:
  D.26361 = 12;
  return D.26361;
  <D.20931>:
  D.26361 = 11;
  return D.26361;
  <D.20932>:
  D.26361 = 13;
  return D.26361;
  <D.20933>:
  D.26361 = 14;
  return D.26361;
  <D.20934>:
  {
    struct MonoClass * klass;

    D.26355 = type->type;
    klass = D.26355->data.klass;
    D.26362 = BIT_FIELD_REF <*klass, 8, 160>;
    D.26363 = D.26362 & 16;
    if (D.26363 != 0) goto <D.26364>; else goto <D.26365>;
    <D.26364>:
    D.26366 = mono_class_enum_basetype (klass);
    D.26367 = D.26366->type;
    t = (int) D.26367;
    goto handle_enum;
    <D.26365>:
    D.26368 = klass->image;
    D.26369 = mono_is_corlib_image (D.26368);
    if (D.26369 != 0) goto <D.26370>; else goto <D.26371>;
    <D.26370>:
    {
      size_t __s1_len;
      size_t __s2_len;

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

        __s2 = klass->name_space;
        D.26375 = "System";
        D.26376 = MEM[(const unsigned char *)D.26375];
        D.26377 = (int) D.26376;
        D.26378 = *__s2;
        D.26379 = (int) D.26378;
        __result = D.26377 - D.26379;
        {
          D.26380 = __s2_len != 0;
          D.26381 = __result == 0;
          D.26382 = D.26380 & D.26381;
          if (D.26382 != 0) goto <D.26383>; else goto <D.26384>;
          <D.26383>:
          D.26385 = &MEM[(void *)"System" + 1B];
          D.26386 = *D.26385;
          D.26387 = (int) D.26386;
          D.26388 = __s2 + 1;
          D.26389 = *D.26388;
          D.26390 = (int) D.26389;
          __result = D.26387 - D.26390;
          D.26391 = __s2_len > 1;
          D.26381 = __result == 0;
          D.26392 = D.26391 & D.26381;
          if (D.26392 != 0) goto <D.26393>; else goto <D.26394>;
          <D.26393>:
          D.26395 = &MEM[(void *)"System" + 2B];
          D.26396 = *D.26395;
          D.26397 = (int) D.26396;
          D.26398 = __s2 + 2;
          D.26399 = *D.26398;
          D.26400 = (int) D.26399;
          __result = D.26397 - D.26400;
          D.26401 = __s2_len > 2;
          D.26381 = __result == 0;
          D.26402 = D.26401 & D.26381;
          if (D.26402 != 0) goto <D.26403>; else goto <D.26404>;
          <D.26403>:
          D.26405 = &MEM[(void *)"System" + 3B];
          D.26406 = *D.26405;
          D.26407 = (int) D.26406;
          D.26408 = __s2 + 3;
          D.26409 = *D.26408;
          D.26410 = (int) D.26409;
          __result = D.26407 - D.26410;
          <D.26404>:
          <D.26394>:
          <D.26384>:
        }
        D.20943 = __result;
      }
      iftmp.56 = -D.20943;
      goto <D.26411>;
      <D.26374>:
      D.26412 = klass->name_space;
      iftmp.56 = __builtin_strcmp (D.26412, "System");
      <D.26411>:
      D.20944 = iftmp.56;
    }
    if (D.20944 == 0) goto <D.26413>; else goto <D.26414>;
    <D.26413>:
    {
      size_t __s1_len;
      size_t __s2_len;

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

        __s2 = klass->name;
        D.26418 = "Decimal";
        D.26419 = MEM[(const unsigned char *)D.26418];
        D.26420 = (int) D.26419;
        D.26421 = *__s2;
        D.26422 = (int) D.26421;
        __result = D.26420 - D.26422;
        {
          D.26423 = __s2_len != 0;
          D.26424 = __result == 0;
          D.26425 = D.26423 & D.26424;
          if (D.26425 != 0) goto <D.26426>; else goto <D.26427>;
          <D.26426>:
          D.26428 = &MEM[(void *)"Decimal" + 1B];
          D.26429 = *D.26428;
          D.26430 = (int) D.26429;
          D.26431 = __s2 + 1;
          D.26432 = *D.26431;
          D.26433 = (int) D.26432;
          __result = D.26430 - D.26433;
          D.26434 = __s2_len > 1;
          D.26424 = __result == 0;
          D.26435 = D.26434 & D.26424;
          if (D.26435 != 0) goto <D.26436>; else goto <D.26437>;
          <D.26436>:
          D.26438 = &MEM[(void *)"Decimal" + 2B];
          D.26439 = *D.26438;
          D.26440 = (int) D.26439;
          D.26441 = __s2 + 2;
          D.26442 = *D.26441;
          D.26443 = (int) D.26442;
          __result = D.26440 - D.26443;
          D.26444 = __s2_len > 2;
          D.26424 = __result == 0;
          D.26445 = D.26444 & D.26424;
          if (D.26445 != 0) goto <D.26446>; else goto <D.26447>;
          <D.26446>:
          D.26448 = &MEM[(void *)"Decimal" + 3B];
          D.26449 = *D.26448;
          D.26450 = (int) D.26449;
          D.26451 = __s2 + 3;
          D.26452 = *D.26451;
          D.26453 = (int) D.26452;
          __result = D.26450 - D.26453;
          <D.26447>:
          <D.26437>:
          <D.26427>:
        }
        D.20952 = __result;
      }
      iftmp.57 = -D.20952;
      goto <D.26454>;
      <D.26417>:
      D.26455 = klass->name;
      iftmp.57 = __builtin_strcmp (D.26455, "Decimal");
      <D.26454>:
      D.20953 = iftmp.57;
    }
    if (D.20953 == 0) goto <D.26456>; else goto <D.26457>;
    <D.26456>:
    D.26361 = 15;
    return D.26361;
    <D.26457>:
    {
      size_t __s1_len;
      size_t __s2_len;

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

        __s2 = klass->name;
        D.26461 = "DateTime";
        D.26462 = MEM[(const unsigned char *)D.26461];
        D.26463 = (int) D.26462;
        D.26464 = *__s2;
        D.26465 = (int) D.26464;
        __result = D.26463 - D.26465;
        {
          D.26466 = __s2_len != 0;
          D.26467 = __result == 0;
          D.26468 = D.26466 & D.26467;
          if (D.26468 != 0) goto <D.26469>; else goto <D.26470>;
          <D.26469>:
          D.26471 = &MEM[(void *)"DateTime" + 1B];
          D.26472 = *D.26471;
          D.26473 = (int) D.26472;
          D.26474 = __s2 + 1;
          D.26475 = *D.26474;
          D.26476 = (int) D.26475;
          __result = D.26473 - D.26476;
          D.26477 = __s2_len > 1;
          D.26467 = __result == 0;
          D.26478 = D.26477 & D.26467;
          if (D.26478 != 0) goto <D.26479>; else goto <D.26480>;
          <D.26479>:
          D.26481 = &MEM[(void *)"DateTime" + 2B];
          D.26482 = *D.26481;
          D.26483 = (int) D.26482;
          D.26484 = __s2 + 2;
          D.26485 = *D.26484;
          D.26486 = (int) D.26485;
          __result = D.26483 - D.26486;
          D.26487 = __s2_len > 2;
          D.26467 = __result == 0;
          D.26488 = D.26487 & D.26467;
          if (D.26488 != 0) goto <D.26489>; else goto <D.26490>;
          <D.26489>:
          D.26491 = &MEM[(void *)"DateTime" + 3B];
          D.26492 = *D.26491;
          D.26493 = (int) D.26492;
          D.26494 = __s2 + 3;
          D.26495 = *D.26494;
          D.26496 = (int) D.26495;
          __result = D.26493 - D.26496;
          <D.26490>:
          <D.26480>:
          <D.26470>:
        }
        D.20961 = __result;
      }
      iftmp.58 = -D.20961;
      goto <D.26497>;
      <D.26460>:
      D.26455 = klass->name;
      iftmp.58 = __builtin_strcmp (D.26455, "DateTime");
      <D.26497>:
      D.20962 = iftmp.58;
    }
    if (D.20962 == 0) goto <D.26498>; else goto <D.26499>;
    <D.26498>:
    D.26361 = 16;
    return D.26361;
    <D.26499>:
    <D.26414>:
    <D.26371>:
    D.26361 = 1;
    return D.26361;
  }
  <D.20963>:
  D.26361 = 18;
  return D.26361;
  <D.20964>:
  <D.20965>:
  <D.20966>:
  <D.20967>:
  <D.20968>:
  <D.20969>:
  D.26361 = 1;
  return D.26361;
  <D.20970>:
  {
    struct MonoClass * klass;

    D.26355 = type->type;
    klass = D.26355->data.klass;
    D.26500 = klass->image;
    D.26501 = mono_defaults.corlib;
    if (D.26500 == D.26501) goto <D.26502>; else goto <D.26503>;
    <D.26502>:
    {
      size_t __s1_len;
      size_t __s2_len;

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

        __s2 = klass->name_space;
        D.26375 = "System";
        D.26376 = MEM[(const unsigned char *)D.26375];
        D.26377 = (int) D.26376;
        D.26507 = *__s2;
        D.26508 = (int) D.26507;
        __result = D.26377 - D.26508;
        {
          D.26509 = __s2_len != 0;
          D.26510 = __result == 0;
          D.26511 = D.26509 & D.26510;
          if (D.26511 != 0) goto <D.26512>; else goto <D.26513>;
          <D.26512>:
          D.26385 = &MEM[(void *)"System" + 1B];
          D.26386 = *D.26385;
          D.26387 = (int) D.26386;
          D.26514 = __s2 + 1;
          D.26515 = *D.26514;
          D.26516 = (int) D.26515;
          __result = D.26387 - D.26516;
          D.26517 = __s2_len > 1;
          D.26510 = __result == 0;
          D.26518 = D.26517 & D.26510;
          if (D.26518 != 0) goto <D.26519>; else goto <D.26520>;
          <D.26519>:
          D.26395 = &MEM[(void *)"System" + 2B];
          D.26396 = *D.26395;
          D.26397 = (int) D.26396;
          D.26521 = __s2 + 2;
          D.26522 = *D.26521;
          D.26523 = (int) D.26522;
          __result = D.26397 - D.26523;
          D.26524 = __s2_len > 2;
          D.26510 = __result == 0;
          D.26525 = D.26524 & D.26510;
          if (D.26525 != 0) goto <D.26526>; else goto <D.26527>;
          <D.26526>:
          D.26405 = &MEM[(void *)"System" + 3B];
          D.26406 = *D.26405;
          D.26407 = (int) D.26406;
          D.26528 = __s2 + 3;
          D.26529 = *D.26528;
          D.26530 = (int) D.26529;
          __result = D.26407 - D.26530;
          <D.26527>:
          <D.26520>:
          <D.26513>:
        }
        D.20979 = __result;
      }
      iftmp.59 = -D.20979;
      goto <D.26531>;
      <D.26506>:
      D.26532 = klass->name_space;
      iftmp.59 = __builtin_strcmp (D.26532, "System");
      <D.26531>:
      D.20980 = iftmp.59;
    }
    if (D.20980 == 0) goto <D.26533>; else goto <D.26534>;
    <D.26533>:
    {
      size_t __s1_len;
      size_t __s2_len;

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

        __s2 = klass->name;
        D.26538 = "DBNull";
        D.26539 = MEM[(const unsigned char *)D.26538];
        D.26540 = (int) D.26539;
        D.26541 = *__s2;
        D.26542 = (int) D.26541;
        __result = D.26540 - D.26542;
        {
          D.26543 = __s2_len != 0;
          D.26544 = __result == 0;
          D.26545 = D.26543 & D.26544;
          if (D.26545 != 0) goto <D.26546>; else goto <D.26547>;
          <D.26546>:
          D.26548 = &MEM[(void *)"DBNull" + 1B];
          D.26549 = *D.26548;
          D.26550 = (int) D.26549;
          D.26551 = __s2 + 1;
          D.26552 = *D.26551;
          D.26553 = (int) D.26552;
          __result = D.26550 - D.26553;
          D.26554 = __s2_len > 1;
          D.26544 = __result == 0;
          D.26555 = D.26554 & D.26544;
          if (D.26555 != 0) goto <D.26556>; else goto <D.26557>;
          <D.26556>:
          D.26558 = &MEM[(void *)"DBNull" + 2B];
          D.26559 = *D.26558;
          D.26560 = (int) D.26559;
          D.26561 = __s2 + 2;
          D.26562 = *D.26561;
          D.26563 = (int) D.26562;
          __result = D.26560 - D.26563;
          D.26564 = __s2_len > 2;
          D.26544 = __result == 0;
          D.26565 = D.26564 & D.26544;
          if (D.26565 != 0) goto <D.26566>; else goto <D.26567>;
          <D.26566>:
          D.26568 = &MEM[(void *)"DBNull" + 3B];
          D.26569 = *D.26568;
          D.26570 = (int) D.26569;
          D.26571 = __s2 + 3;
          D.26572 = *D.26571;
          D.26573 = (int) D.26572;
          __result = D.26570 - D.26573;
          <D.26567>:
          <D.26557>:
          <D.26547>:
        }
        D.20988 = __result;
      }
      iftmp.60 = -D.20988;
      goto <D.26574>;
      <D.26537>:
      D.26575 = klass->name;
      iftmp.60 = __builtin_strcmp (D.26575, "DBNull");
      <D.26574>:
      D.20989 = iftmp.60;
    }
    if (D.20989 == 0) goto <D.26576>; else goto <D.26577>;
    <D.26576>:
    D.26361 = 2;
    return D.26361;
    <D.26577>:
    <D.26534>:
    <D.26503>:
  }
  D.26361 = 1;
  return D.26361;
  <D.20990>:
  D.26361 = 1;
  return D.26361;
  <D.20991>:
  monoeg_g_log (0B, 4, "type 0x%02x not handled in GetTypeCode()", t);
  <D.20992>:
  goto <D.20992>;
  D.26361 = 0;
  return D.26361;
}


ves_icall_Type_GetPacking (struct MonoReflectionType * type, guint32 * packing, guint32 * size)
{
  struct MonoType * D.26579;
  struct MonoImage * D.26580;
  unsigned char D.26581;
  unsigned char D.26582;
  int D.26585;
  unsigned int D.26586;
  int D.26587;
  unsigned int D.26588;
  unsigned int D.26590;
  struct MonoClass * klass;

  D.26579 = type->type;
  klass = mono_class_from_mono_type (D.26579);
  mono_class_init_or_throw (klass);
  D.26580 = klass->image;
  D.26581 = BIT_FIELD_REF <*D.26580, 8, 128>;
  D.26582 = D.26581 & 8;
  if (D.26582 != 0) goto <D.26583>; else goto <D.26584>;
  <D.26583>:
  {
    struct MonoReflectionTypeBuilder * tb;

    tb = type;
    D.26585 = tb->packing_size;
    D.26586 = (unsigned int) D.26585;
    *packing = D.26586;
    D.26587 = tb->class_size;
    D.26588 = (unsigned int) D.26587;
    *size = D.26588;
  }
  goto <D.26589>;
  <D.26584>:
  D.26590 = klass->type_token;
  D.26580 = klass->image;
  mono_metadata_packing_from_typedef (D.26580, D.26590, packing, size);
  <D.26589>:
}


ves_icall_Type_GetInterfaceMapData (struct MonoReflectionType * type, struct MonoReflectionType * iface, struct MonoArray * * targets, struct MonoArray * * methods)
{
  struct MonoType * D.26591;
  struct MonoType * D.26592;
  struct MonoVTable * D.26595;
  unsigned int len.61;
  struct MonoClass * D.26597;
  struct MonoArray * D.26598;
  struct MonoArray * D.26599;
  unsigned int i.62;
  struct MonoArray * D.26601;
  struct MonoMethod * * D.26602;
  int D.26603;
  unsigned int D.26604;
  unsigned int D.26605;
  struct MonoMethod * * D.26606;
  struct MonoMethod * D.26607;
  struct MonoArray * D.26608;
  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.26591 = type->type;
      class = mono_class_from_mono_type (D.26591);
      D.26592 = iface->type;
      iclass = mono_class_from_mono_type (D.26592);
      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.26593>; else goto <D.26594>;
      <D.26593>:
      return;
      <D.26594>:
      len = mono_class_num_methods (iclass);
      D.26595 = MEM[(struct MonoObject *)type].vtable;
      domain = D.26595->domain;
      len.61 = (unsigned int) len;
      D.26597 = mono_defaults.method_info_class;
      D.26598 = mono_array_new (domain, D.26597, len.61);
      mono_gc_wbarrier_generic_store (targets, D.26598);
      len.61 = (unsigned int) len;
      D.26597 = mono_defaults.method_info_class;
      D.26599 = mono_array_new (domain, D.26597, len.61);
      mono_gc_wbarrier_generic_store (methods, D.26599);
      iter = 0B;
      goto <D.21261>;
      <D.21260>:
      member = mono_method_get_object (domain, method, iclass);
      {
        void * * __p;

        i.62 = (unsigned int) i;
        D.26601 = *methods;
        __p = mono_array_addr_with_size (D.26601, 4, i.62);
        D.26601 = *methods;
        mono_gc_wbarrier_set_arrayref (D.26601, __p, member);
      }
      D.26602 = class->vtable;
      D.26603 = i + ioffset;
      D.26604 = (unsigned int) D.26603;
      D.26605 = D.26604 * 4;
      D.26606 = D.26602 + D.26605;
      D.26607 = *D.26606;
      member = mono_method_get_object (domain, D.26607, class);
      {
        void * * __p;

        i.62 = (unsigned int) i;
        D.26608 = *targets;
        __p = mono_array_addr_with_size (D.26608, 4, i.62);
        D.26608 = *targets;
        mono_gc_wbarrier_set_arrayref (D.26608, __p, member);
      }
      i = i + 1;
      <D.21261>:
      method = mono_class_get_methods (iclass, &iter);
      if (method != 0B) goto <D.21260>; else goto <D.21262>;
      <D.21262>:
    }
  finally
    {
      variance_used = {CLOBBER};
      iter = {CLOBBER};
    }
}


ves_icall_Type_GetGenericTypeDefinition_impl (struct MonoReflectionType * type)
{
  struct MonoType * D.26612;
  unsigned char D.26613;
  unsigned char D.26614;
  struct MonoReflectionType * D.26617;
  struct MonoGenericContainer * D.26618;
  struct MonoGenericClass * D.26621;
  unsigned char D.26625;
  unsigned char D.26626;
  struct MonoType * D.26629;
  struct MonoVTable * D.26630;
  struct MonoDomain * D.26631;
  struct MonoClass * klass;

  D.26612 = type->type;
  D.26613 = BIT_FIELD_REF <*D.26612, 8, 56>;
  D.26614 = D.26613 & 64;
  if (D.26614 != 0) goto <D.26615>; else goto <D.26616>;
  <D.26615>:
  D.26617 = 0B;
  return D.26617;
  <D.26616>:
  D.26612 = type->type;
  klass = mono_class_from_mono_type (D.26612);
  D.26618 = klass->generic_container;
  if (D.26618 != 0B) goto <D.26619>; else goto <D.26620>;
  <D.26619>:
  D.26617 = type;
  return D.26617;
  <D.26620>:
  D.26621 = klass->generic_class;
  if (D.26621 != 0B) goto <D.26622>; else goto <D.26623>;
  <D.26622>:
  {
    struct MonoClass * generic_class;
    void * tb;

    D.26621 = klass->generic_class;
    generic_class = D.26621->container_class;
    tb = mono_class_get_ref_info (generic_class);
    D.26625 = BIT_FIELD_REF <*generic_class, 8, 160>;
    D.26626 = D.26625 & 128;
    if (D.26626 != 0) goto <D.26627>; else goto <D.26624>;
    <D.26627>:
    if (tb != 0B) goto <D.26628>; else goto <D.26624>;
    <D.26628>:
    D.26617 = tb;
    return D.26617;
    <D.26624>:
    D.26629 = &generic_class->byval_arg;
    D.26630 = MEM[(struct MonoObject *)type].vtable;
    D.26631 = D.26630->domain;
    D.26617 = mono_type_get_object (D.26631, D.26629);
    return D.26617;
  }
  <D.26623>:
  D.26617 = 0B;
  return D.26617;
}


ves_icall_Type_GetGenericParameterPosition (struct MonoReflectionType * type)
{
  struct MonoVTable * D.26637;
  struct MonoClass * D.26638;
  struct MonoImage * D.26639;
  struct MonoImage * D.26640;
  struct MonoType * D.26642;
  gint32 D.26643;
  unsigned char D.26644;
  struct MonoGenericParam * D.26647;
  short unsigned int D.26648;

  if (type != 0B) goto <D.26635>; else goto <D.26636>;
  <D.26635>:
  D.26637 = MEM[(struct MonoObject *)type].vtable;
  D.26638 = D.26637->klass;
  D.26639 = D.26638->image;
  D.26640 = mono_defaults.corlib;
  if (D.26639 != D.26640) goto <D.26633>; else goto <D.26641>;
  <D.26641>:
  D.26642 = type->type;
  if (D.26642 == 0B) goto <D.26633>; else goto <D.26634>;
  <D.26633>:
  D.26643 = -1;
  return D.26643;
  <D.26634>:
  <D.26636>:
  D.26642 = type->type;
  D.26644 = is_generic_parameter (D.26642);
  if (D.26644 != 0) goto <D.26645>; else goto <D.26646>;
  <D.26645>:
  D.26642 = type->type;
  D.26647 = D.26642->data.generic_param;
  D.26648 = D.26647->num;
  D.26643 = (gint32) D.26648;
  return D.26643;
  <D.26646>:
  D.26643 = -1;
  return D.26643;
}


ves_icall_Type_GetGenericParameterConstraints (struct MonoReflectionType * type)
{
  int iftmp.63;
  struct MonoVTable * D.26655;
  struct MonoClass * D.26656;
  struct MonoImage * D.26657;
  struct MonoImage * D.26658;
  struct MonoType * D.26660;
  _Bool D.26661;
  long int D.26662;
  long int D.26663;
  struct MonoGenericParamInfo * iftmp.64;
  struct MonoGenericParam * D.26667;
  struct MonoGenericContainer * D.26668;
  struct MonoClass * D.26673;
  unsigned int count.65;
  struct MonoClass * D.26675;
  unsigned int i.66;
  struct MonoClass * * D.26677;
  unsigned int i.67;
  unsigned int D.26679;
  struct MonoClass * * D.26680;
  struct MonoClass * D.26681;
  struct MonoType * D.26682;
  struct MonoReflectionType * D.26683;
  struct MonoArray * D.26684;
  struct MonoGenericParamInfo * param_info;
  struct MonoDomain * domain;
  struct MonoClass * * ptr;
  struct MonoArray * res;
  int i;
  int count;

  if (type != 0B) goto <D.26654>; else goto <D.26651>;
  <D.26654>:
  D.26655 = MEM[(struct MonoObject *)type].vtable;
  D.26656 = D.26655->klass;
  D.26657 = D.26656->image;
  D.26658 = mono_defaults.corlib;
  if (D.26657 != D.26658) goto <D.26652>; else goto <D.26659>;
  <D.26659>:
  D.26660 = type->type;
  if (D.26660 == 0B) goto <D.26652>; else goto <D.26651>;
  <D.26652>:
  iftmp.63 = 1;
  goto <D.26653>;
  <D.26651>:
  iftmp.63 = 0;
  <D.26653>:
  D.26661 = iftmp.63 != 0;
  D.26662 = (long int) D.26661;
  D.26663 = __builtin_expect (D.26662, 0);
  if (D.26663 != 0) goto <D.26664>; else goto <D.26665>;
  <D.26664>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "icall.c", 2493, "IS_MONOTYPE (type)");
  <D.26665>:
  D.26655 = MEM[(struct MonoObject *)type].vtable;
  domain = D.26655->domain;
  D.26660 = type->type;
  D.26667 = D.26660->data.generic_param;
  D.26668 = D.26667->owner;
  if (D.26668 != 0B) goto <D.26669>; else goto <D.26670>;
  <D.26669>:
  D.26660 = type->type;
  D.26667 = D.26660->data.generic_param;
  iftmp.64 = &MEM[(struct MonoGenericParamFull *)D.26667].info;
  goto <D.26671>;
  <D.26670>:
  iftmp.64 = 0B;
  <D.26671>:
  param_info = iftmp.64;
  count = 0;
  ptr = param_info->constraints;
  goto <D.21392>;
  <D.21391>:
  ptr = ptr + 4;
  count = count + 1;
  <D.21392>:
  if (ptr != 0B) goto <D.26672>; else goto <D.21393>;
  <D.26672>:
  D.26673 = *ptr;
  if (D.26673 != 0B) goto <D.21391>; else goto <D.21393>;
  <D.21393>:
  count.65 = (unsigned int) count;
  D.26675 = mono_defaults.monotype_class;
  res = mono_array_new (domain, D.26675, count.65);
  i = 0;
  goto <D.21396>;
  <D.21395>:
  {
    void * * __p;

    i.66 = (unsigned int) i;
    __p = mono_array_addr_with_size (res, 4, i.66);
    D.26677 = param_info->constraints;
    i.67 = (unsigned int) i;
    D.26679 = i.67 * 4;
    D.26680 = D.26677 + D.26679;
    D.26681 = *D.26680;
    D.26682 = &D.26681->byval_arg;
    D.26683 = mono_type_get_object (domain, D.26682);
    mono_gc_wbarrier_set_arrayref (res, __p, D.26683);
  }
  i = i + 1;
  <D.21396>:
  if (i < count) goto <D.21395>; else goto <D.21397>;
  <D.21397>:
  D.26684 = res;
  return D.26684;
}


ves_icall_Type_GetGenericParameterAttributes (struct MonoReflectionType * type)
{
  int iftmp.68;
  struct MonoVTable * D.26691;
  struct MonoClass * D.26692;
  struct MonoImage * D.26693;
  struct MonoImage * D.26694;
  struct MonoType * D.26696;
  _Bool D.26697;
  long int D.26698;
  long int D.26699;
  unsigned char D.26702;
  _Bool D.26703;
  long int D.26704;
  long int D.26705;
  GenericParameterAttributes D.26708;
  struct MonoGenericParamInfo * iftmp.69;
  struct MonoGenericParam * D.26710;
  struct MonoGenericContainer * D.26711;
  short unsigned int D.26715;

  if (type != 0B) goto <D.26690>; else goto <D.26687>;
  <D.26690>:
  D.26691 = MEM[(struct MonoObject *)type].vtable;
  D.26692 = D.26691->klass;
  D.26693 = D.26692->image;
  D.26694 = mono_defaults.corlib;
  if (D.26693 != D.26694) goto <D.26688>; else goto <D.26695>;
  <D.26695>:
  D.26696 = type->type;
  if (D.26696 == 0B) goto <D.26688>; else goto <D.26687>;
  <D.26688>:
  iftmp.68 = 1;
  goto <D.26689>;
  <D.26687>:
  iftmp.68 = 0;
  <D.26689>:
  D.26697 = iftmp.68 != 0;
  D.26698 = (long int) D.26697;
  D.26699 = __builtin_expect (D.26698, 0);
  if (D.26699 != 0) goto <D.26700>; else goto <D.26701>;
  <D.26700>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "icall.c", 2477, "IS_MONOTYPE (type)");
  <D.26701>:
  D.26696 = type->type;
  D.26702 = is_generic_parameter (D.26696);
  D.26703 = D.26702 == 0;
  D.26704 = (long int) D.26703;
  D.26705 = __builtin_expect (D.26704, 0);
  if (D.26705 != 0) goto <D.26706>; else goto <D.26707>;
  <D.26706>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "icall.c", 2478, "is_generic_parameter (type->type)");
  <D.26707>:
  D.26696 = type->type;
  D.26710 = D.26696->data.generic_param;
  D.26711 = D.26710->owner;
  if (D.26711 != 0B) goto <D.26712>; else goto <D.26713>;
  <D.26712>:
  D.26696 = type->type;
  D.26710 = D.26696->data.generic_param;
  iftmp.69 = &MEM[(struct MonoGenericParamFull *)D.26710].info;
  goto <D.26714>;
  <D.26713>:
  iftmp.69 = 0B;
  <D.26714>:
  D.26715 = iftmp.69->flags;
  D.26708 = (GenericParameterAttributes) D.26715;
  return D.26708;
}


ves_icall_System_Type_EqualsInternal (struct MonoReflectionType * type, struct MonoReflectionType * c)
{
  struct MonoType * D.26719;
  struct MonoType * D.26721;
  MonoBoolean D.26723;
  int D.26724;
  _Bool D.26725;

  if (c != 0B) goto <D.26718>; else goto <D.26717>;
  <D.26718>:
  D.26719 = type->type;
  if (D.26719 != 0B) goto <D.26720>; else goto <D.26717>;
  <D.26720>:
  D.26721 = c->type;
  if (D.26721 != 0B) goto <D.26722>; else goto <D.26717>;
  <D.26722>:
  D.26721 = c->type;
  D.26719 = type->type;
  D.26724 = mono_metadata_type_equal (D.26719, D.26721);
  D.26723 = (MonoBoolean) D.26724;
  return D.26723;
  <D.26717>:
  D.26725 = type == c;
  D.26723 = (MonoBoolean) D.26725;
  return D.26723;
}


ves_icall_System_Text_Encoding_InternalCodePage (gint32 * int_code_page)
{
  const char * cset.70;
  char D.26728;
  const short unsigned int * * D.26731;
  const short unsigned int * D.26732;
  unsigned int D.26733;
  unsigned int D.26734;
  const short unsigned int * D.26735;
  short unsigned int D.26736;
  int D.26737;
  int D.26738;
  int D.22943;
  int D.26743;
  int D.26744;
  const int iftmp.71;
  unsigned int __c.72;
  unsigned int D.26749;
  const __int32_t * * D.26752;
  const __int32_t * D.26753;
  unsigned int __c.73;
  unsigned int D.26755;
  const __int32_t * D.26756;
  unsigned int D.26760;
  const __int32_t * D.26761;
  char D.26762;
  int p.74;
  int D.22956;
  char * D.26770;
  int D.26773;
  int D.26774;
  struct MonoString * D.26778;
  struct MonoDomain * D.26779;
  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.70 = cset;
      codepage = __strdup (cset.70);
      c = codepage;
      c = codepage;
      goto <D.22945>;
      <D.22944>:
      D.26728 = *c;
      if (D.26728 >= 0) goto <D.26729>; else goto <D.26730>;
      <D.26729>:
      D.26731 = __ctype_b_loc ();
      D.26732 = *D.26731;
      D.26728 = *c;
      D.26733 = (unsigned int) D.26728;
      D.26734 = D.26733 * 2;
      D.26735 = D.26732 + D.26734;
      D.26736 = *D.26735;
      D.26737 = (int) D.26736;
      D.26738 = D.26737 & 1024;
      if (D.26738 != 0) goto <D.26739>; else goto <D.26740>;
      <D.26739>:
      {
        int __res;

        {
          if (0 != 0) goto <D.26741>; else goto <D.26742>;
          <D.26741>:
          D.26728 = *c;
          D.26743 = (int) D.26728;
          D.26744 = __builtin_constant_p (D.26743);
          if (D.26744 != 0) goto <D.26745>; else goto <D.26746>;
          <D.26745>:
          {
            int __c;

            D.26728 = *c;
            __c = (int) D.26728;
            __c.72 = (unsigned int) __c;
            D.26749 = __c.72 + 128;
            if (D.26749 <= 383) goto <D.26750>; else goto <D.26751>;
            <D.26750>:
            D.26752 = __ctype_tolower_loc ();
            D.26753 = *D.26752;
            __c.73 = (unsigned int) __c;
            D.26755 = __c.73 * 4;
            D.26756 = D.26753 + D.26755;
            iftmp.71 = *D.26756;
            goto <D.26757>;
            <D.26751>:
            iftmp.71 = __c;
            <D.26757>:
            __res = iftmp.71;
          }
          goto <D.26758>;
          <D.26746>:
          D.26728 = *c;
          D.26743 = (int) D.26728;
          __res = tolower (D.26743);
          <D.26758>:
          goto <D.26759>;
          <D.26742>:
          D.26752 = __ctype_tolower_loc ();
          D.26753 = *D.26752;
          D.26728 = *c;
          D.26733 = (unsigned int) D.26728;
          D.26760 = D.26733 * 4;
          D.26761 = D.26753 + D.26760;
          __res = *D.26761;
          <D.26759>:
        }
        D.22943 = __res;
      }
      D.26762 = (char) D.22943;
      *c = D.26762;
      <D.26740>:
      <D.26730>:
      D.26728 = *c;
      if (D.26728 == 45) goto <D.26763>; else goto <D.26764>;
      <D.26763>:
      *c = 95;
      <D.26764>:
      c = c + 1;
      <D.22945>:
      D.26728 = *c;
      if (D.26728 != 0) goto <D.22944>; else goto <D.22946>;
      <D.22946>:
      p = encodings[0];
      code = 0;
      i = 0;
      goto <D.22947>;
      <D.22958>:
      p.74 = (int) p;
      if (p.74 <= 6) goto <D.26766>; else goto <D.26767>;
      <D.26766>:
      code = (int) p;
      i = i + 1;
      p = encodings[i];
      // predicted unlikely by continue predictor.
      goto <D.22947>;
      <D.26767>:
      {
        size_t __s1_len;
        size_t __s2_len;

        D.22956 = __builtin_strcmp (p, codepage);
      }
      if (D.22956 == 0) goto <D.26768>; else goto <D.26769>;
      <D.26768>:
      *int_code_page = code;
      goto <D.22957>;
      <D.26769>:
      i = i + 1;
      p = encodings[i];
      <D.22947>:
      if (p != 0B) goto <D.22958>; else goto <D.22957>;
      <D.22957>:
      D.26770 = strstr (codepage, "utf_8");
      if (D.26770 != 0B) goto <D.26771>; else goto <D.26772>;
      <D.26771>:
      D.26773 = *int_code_page;
      D.26774 = D.26773 | 268435456;
      *int_code_page = D.26774;
      <D.26772>:
      free (codepage);
      if (want_name != 0) goto <D.26776>; else goto <D.26775>;
      <D.26776>:
      D.26773 = *int_code_page;
      if (D.26773 == -1) goto <D.26777>; else goto <D.26775>;
      <D.26777>:
      cset.70 = cset;
      D.26779 = mono_domain_get ();
      D.26778 = mono_string_new (D.26779, cset.70);
      return D.26778;
      <D.26775>:
      D.26778 = 0B;
      return D.26778;
    }
  finally
    {
      cset = {CLOBBER};
    }
}


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

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


ves_icall_IsTransparentProxy (struct MonoObject * proxy)
{
  MonoBoolean D.26786;
  struct MonoVTable * D.26787;
  struct MonoClass * D.26788;
  struct MonoClass * D.26789;

  if (proxy == 0B) goto <D.26784>; else goto <D.26785>;
  <D.26784>:
  D.26786 = 0;
  return D.26786;
  <D.26785>:
  D.26787 = proxy->vtable;
  D.26788 = D.26787->klass;
  D.26789 = mono_defaults.transparent_proxy_class;
  if (D.26788 == D.26789) goto <D.26790>; else goto <D.26791>;
  <D.26790>:
  D.26786 = 1;
  return D.26786;
  <D.26791>:
  D.26786 = 0;
  return D.26786;
}


ves_icall_InternalExecute (struct MonoReflectionMethod * method, struct MonoObject * this, struct MonoArray * params, struct MonoArray * * outArgs)
{
  struct MonoVTable * D.26793;
  struct MonoClass * D.26794;
  struct MonoClass * D.26795;
  int D.21543;
  int iftmp.75;
  int D.21542;
  const char[12] * D.26801;
  unsigned char D.26802;
  int D.26803;
  unsigned char D.26804;
  int D.26805;
  _Bool D.26806;
  _Bool D.26807;
  _Bool D.26808;
  const unsigned char * D.26811;
  unsigned char D.26812;
  int D.26813;
  const unsigned char * D.26814;
  unsigned char D.26815;
  int D.26816;
  _Bool D.26817;
  _Bool D.26818;
  const unsigned char * D.26821;
  unsigned char D.26822;
  int D.26823;
  const unsigned char * D.26824;
  unsigned char D.26825;
  int D.26826;
  _Bool D.26827;
  _Bool D.26828;
  const unsigned char * D.26831;
  unsigned char D.26832;
  int D.26833;
  const unsigned char * D.26834;
  unsigned char D.26835;
  int D.26836;
  const char * D.26838;
  struct MonoVTable * D.26841;
  struct MonoClass * D.26842;
  struct MonoRealProxy * D.26845;
  _Bool D.26846;
  long int D.26847;
  long int D.26848;
  char * D.26851;
  struct MonoType * D.26854;
  unsigned char D.26855;
  unsigned char D.26856;
  int D.26859;
  sizetype D.26860;
  void * D.26861;
  void * * D.26863;
  struct MonoObject * D.26864;
  int D.21561;
  int iftmp.76;
  int D.21560;
  const char[12] * D.26868;
  unsigned char D.26869;
  int D.26870;
  unsigned char D.26871;
  int D.26872;
  _Bool D.26873;
  _Bool D.26874;
  _Bool D.26875;
  const unsigned char * D.26878;
  unsigned char D.26879;
  int D.26880;
  const unsigned char * D.26881;
  unsigned char D.26882;
  int D.26883;
  _Bool D.26884;
  _Bool D.26885;
  const unsigned char * D.26888;
  unsigned char D.26889;
  int D.26890;
  const unsigned char * D.26891;
  unsigned char D.26892;
  int D.26893;
  _Bool D.26894;
  _Bool D.26895;
  const unsigned char * D.26898;
  unsigned char D.26899;
  int D.26900;
  const unsigned char * D.26901;
  unsigned char D.26902;
  int D.26903;
  struct MonoRealProxy * D.26909;
  char * D.26912;
  struct MonoType * D.26915;
  char * D.26916;
  unsigned char D.26917;
  unsigned char D.26918;
  int D.26921;
  int D.26922;
  unsigned int D.26923;
  _Bool D.26924;
  long int D.26925;
  long int D.26926;
  void * D.26929;
  int D.26930;
  sizetype D.26931;
  void * D.26932;
  struct MonoType * D.26934;
  unsigned char D.26935;
  unsigned char D.26936;
  unsigned int i.77;
  unsigned int D.26940;
  unsigned int outarg_count.78;
  int D.21584;
  int iftmp.79;
  int D.21583;
  struct MonoMethod * D.26945;
  const char[6] * D.26946;
  unsigned char D.26947;
  int D.26948;
  unsigned char D.26949;
  int D.26950;
  _Bool D.26951;
  _Bool D.26952;
  _Bool D.26953;
  const unsigned char * D.26956;
  unsigned char D.26957;
  int D.26958;
  const unsigned char * D.26959;
  unsigned char D.26960;
  int D.26961;
  _Bool D.26962;
  _Bool D.26963;
  const unsigned char * D.26966;
  unsigned char D.26967;
  int D.26968;
  const unsigned char * D.26969;
  unsigned char D.26970;
  int D.26971;
  _Bool D.26972;
  _Bool D.26973;
  const unsigned char * D.26976;
  unsigned char D.26977;
  int D.26978;
  const unsigned char * D.26979;
  unsigned char D.26980;
  int D.26981;
  const char * D.26983;
  struct MonoClass * D.26988;
  unsigned char D.26989;
  unsigned char D.26990;
  _Bool D.26991;
  long int D.26992;
  long int D.26993;
  char * D.26998;
  unsigned int j.80;
  unsigned int D.27000;
  struct MonoDomain * domain;
  struct MonoMethod * m;
  struct MonoMethodSignature * sig;
  struct MonoArray * out_args;
  struct MonoObject * result;
  int i;
  int j;
  int outarg_count;

  D.26793 = MEM[(struct MonoObject *)method].vtable;
  domain = D.26793->domain;
  m = method->method;
  sig = mono_method_signature (m);
  outarg_count = 0;
  D.26794 = m->klass;
  D.26795 = mono_defaults.object_class;
  if (D.26794 == D.26795) goto <D.26796>; else goto <D.26797>;
  <D.26796>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = m->name;
      D.26801 = "FieldGetter";
      D.26802 = MEM[(const unsigned char *)D.26801];
      D.26803 = (int) D.26802;
      D.26804 = *__s2;
      D.26805 = (int) D.26804;
      __result = D.26803 - D.26805;
      {
        D.26806 = __s2_len != 0;
        D.26807 = __result == 0;
        D.26808 = D.26806 & D.26807;
        if (D.26808 != 0) goto <D.26809>; else goto <D.26810>;
        <D.26809>:
        D.26811 = &MEM[(void *)"FieldGetter" + 1B];
        D.26812 = *D.26811;
        D.26813 = (int) D.26812;
        D.26814 = __s2 + 1;
        D.26815 = *D.26814;
        D.26816 = (int) D.26815;
        __result = D.26813 - D.26816;
        D.26817 = __s2_len > 1;
        D.26807 = __result == 0;
        D.26818 = D.26817 & D.26807;
        if (D.26818 != 0) goto <D.26819>; else goto <D.26820>;
        <D.26819>:
        D.26821 = &MEM[(void *)"FieldGetter" + 2B];
        D.26822 = *D.26821;
        D.26823 = (int) D.26822;
        D.26824 = __s2 + 2;
        D.26825 = *D.26824;
        D.26826 = (int) D.26825;
        __result = D.26823 - D.26826;
        D.26827 = __s2_len > 2;
        D.26807 = __result == 0;
        D.26828 = D.26827 & D.26807;
        if (D.26828 != 0) goto <D.26829>; else goto <D.26830>;
        <D.26829>:
        D.26831 = &MEM[(void *)"FieldGetter" + 3B];
        D.26832 = *D.26831;
        D.26833 = (int) D.26832;
        D.26834 = __s2 + 3;
        D.26835 = *D.26834;
        D.26836 = (int) D.26835;
        __result = D.26833 - D.26836;
        <D.26830>:
        <D.26820>:
        <D.26810>:
      }
      D.21542 = __result;
    }
    iftmp.75 = -D.21542;
    goto <D.26837>;
    <D.26800>:
    D.26838 = m->name;
    iftmp.75 = __builtin_strcmp (D.26838, "FieldGetter");
    <D.26837>:
    D.21543 = iftmp.75;
  }
  if (D.21543 == 0) goto <D.26839>; else goto <D.26840>;
  <D.26839>:
  {
    struct MonoClass * k;
    struct MonoString * name;
    char * str;

    D.26841 = this->vtable;
    k = D.26841->klass;
    D.26842 = mono_defaults.transparent_proxy_class;
    if (D.26842 == k) goto <D.26843>; else goto <D.26844>;
    <D.26843>:
    {
      struct MonoTransparentProxy * tp;

      tp = this;
      D.26845 = tp->rp;
      this = D.26845->unwrapped_server;
      D.26846 = this == 0B;
      D.26847 = (long int) D.26846;
      D.26848 = __builtin_expect (D.26847, 0);
      if (D.26848 != 0) goto <D.26849>; else goto <D.26850>;
      <D.26849>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "icall.c", 2870, "this");
      <D.26850>:
      D.26841 = this->vtable;
      k = D.26841->klass;
    }
    <D.26844>:
    D.26851 = mono_array_addr_with_size (params, 4, 1);
    name = MEM[(struct MonoString * *)D.26851];
    str = mono_string_to_utf8 (name);
    <D.21551>:
    {
      struct MonoClassField * field;

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

        D.26854 = field->type;
        field_klass = mono_class_from_mono_type (D.26854);
        D.26855 = BIT_FIELD_REF <*field_klass, 8, 160>;
        D.26856 = D.26855 & 8;
        if (D.26856 != 0) goto <D.26857>; else goto <D.26858>;
        <D.26857>:
        D.26859 = field->offset;
        D.26860 = (sizetype) D.26859;
        D.26861 = this + D.26860;
        result = mono_value_box (domain, field_klass, D.26861);
        goto <D.26862>;
        <D.26858>:
        D.26859 = field->offset;
        D.26860 = (sizetype) D.26859;
        D.26863 = this + D.26860;
        result = *D.26863;
        <D.26862>:
        D.26795 = mono_defaults.object_class;
        out_args = mono_array_new (domain, D.26795, 1);
        mono_gc_wbarrier_generic_store (outArgs, out_args);
        {
          void * * __p;

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

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

      __s2 = m->name;
      D.26868 = "FieldSetter";
      D.26869 = MEM[(const unsigned char *)D.26868];
      D.26870 = (int) D.26869;
      D.26871 = *__s2;
      D.26872 = (int) D.26871;
      __result = D.26870 - D.26872;
      {
        D.26873 = __s2_len != 0;
        D.26874 = __result == 0;
        D.26875 = D.26873 & D.26874;
        if (D.26875 != 0) goto <D.26876>; else goto <D.26877>;
        <D.26876>:
        D.26878 = &MEM[(void *)"FieldSetter" + 1B];
        D.26879 = *D.26878;
        D.26880 = (int) D.26879;
        D.26881 = __s2 + 1;
        D.26882 = *D.26881;
        D.26883 = (int) D.26882;
        __result = D.26880 - D.26883;
        D.26884 = __s2_len > 1;
        D.26874 = __result == 0;
        D.26885 = D.26884 & D.26874;
        if (D.26885 != 0) goto <D.26886>; else goto <D.26887>;
        <D.26886>:
        D.26888 = &MEM[(void *)"FieldSetter" + 2B];
        D.26889 = *D.26888;
        D.26890 = (int) D.26889;
        D.26891 = __s2 + 2;
        D.26892 = *D.26891;
        D.26893 = (int) D.26892;
        __result = D.26890 - D.26893;
        D.26894 = __s2_len > 2;
        D.26874 = __result == 0;
        D.26895 = D.26894 & D.26874;
        if (D.26895 != 0) goto <D.26896>; else goto <D.26897>;
        <D.26896>:
        D.26898 = &MEM[(void *)"FieldSetter" + 3B];
        D.26899 = *D.26898;
        D.26900 = (int) D.26899;
        D.26901 = __s2 + 3;
        D.26902 = *D.26901;
        D.26903 = (int) D.26902;
        __result = D.26900 - D.26903;
        <D.26897>:
        <D.26887>:
        <D.26877>:
      }
      D.21560 = __result;
    }
    iftmp.76 = -D.21560;
    goto <D.26904>;
    <D.26867>:
    D.26838 = m->name;
    iftmp.76 = __builtin_strcmp (D.26838, "FieldSetter");
    <D.26904>:
    D.21561 = iftmp.76;
  }
  if (D.21561 == 0) goto <D.26905>; else goto <D.26906>;
  <D.26905>:
  {
    struct MonoClass * k;
    struct MonoString * name;
    guint32 size;
    gint32 align;
    char * str;

    try
      {
        D.26841 = this->vtable;
        k = D.26841->klass;
        D.26842 = mono_defaults.transparent_proxy_class;
        if (D.26842 == k) goto <D.26907>; else goto <D.26908>;
        <D.26907>:
        {
          struct MonoTransparentProxy * tp;

          tp = this;
          D.26909 = tp->rp;
          this = D.26909->unwrapped_server;
          D.26846 = this == 0B;
          D.26847 = (long int) D.26846;
          D.26848 = __builtin_expect (D.26847, 0);
          if (D.26848 != 0) goto <D.26910>; else goto <D.26911>;
          <D.26910>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "icall.c", 2909, "this");
          <D.26911>:
          D.26841 = this->vtable;
          k = D.26841->klass;
        }
        <D.26908>:
        D.26912 = mono_array_addr_with_size (params, 4, 1);
        name = MEM[(struct MonoString * *)D.26912];
        str = mono_string_to_utf8 (name);
        <D.21571>:
        {
          struct MonoClassField * field;

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

            D.26915 = field->type;
            field_klass = mono_class_from_mono_type (D.26915);
            D.26916 = mono_array_addr_with_size (params, 4, 2);
            val = MEM[(void * *)D.26916];
            D.26917 = BIT_FIELD_REF <*field_klass, 8, 160>;
            D.26918 = D.26917 & 8;
            if (D.26918 != 0) goto <D.26919>; else goto <D.26920>;
            <D.26919>:
            D.26915 = field->type;
            D.26921 = mono_type_size (D.26915, &align);
            size = (guint32) D.26921;
            D.26922 = mono_class_value_size (field_klass, 0B);
            D.26923 = (unsigned int) D.26922;
            D.26924 = D.26923 != size;
            D.26925 = (long int) D.26924;
            D.26926 = __builtin_expect (D.26925, 0);
            if (D.26926 != 0) goto <D.26927>; else goto <D.26928>;
            <D.26927>:
            monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "icall.c", 2924, "size == mono_class_value_size (field_klass, NULL)");
            <D.26928>:
            D.26929 = val + 8;
            D.26930 = field->offset;
            D.26931 = (sizetype) D.26930;
            D.26932 = this + D.26931;
            mono_gc_wbarrier_value_copy (D.26932, D.26929, 1, field_klass);
            goto <D.26933>;
            <D.26920>:
            D.26930 = field->offset;
            D.26931 = (sizetype) D.26930;
            D.26932 = this + D.26931;
            mono_gc_wbarrier_set_field (this, D.26932, val);
            <D.26933>:
            D.26795 = mono_defaults.object_class;
            out_args = mono_array_new (domain, D.26795, 0);
            mono_gc_wbarrier_generic_store (outArgs, out_args);
            monoeg_g_free (str);
            D.26864 = 0B;
            return D.26864;
          }
          <D.26914>:
          k = k->parent;
        }
        if (k != 0B) goto <D.21571>; else goto <D.21572>;
        <D.21572>:
        monoeg_g_free (str);
        monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "icall.c", 2941);
      }
    finally
      {
        align = {CLOBBER};
      }
  }
  <D.26906>:
  <D.26797>:
  i = 0;
  goto <D.21574>;
  <D.21573>:
  D.26934 = sig->params[i];
  D.26935 = BIT_FIELD_REF <*D.26934, 8, 56>;
  D.26936 = D.26935 & 64;
  if (D.26936 != 0) goto <D.26937>; else goto <D.26938>;
  <D.26937>:
  outarg_count = outarg_count + 1;
  <D.26938>:
  i = i + 1;
  <D.21574>:
  i.77 = (unsigned int) i;
  D.26940 = mono_array_length (params);
  if (i.77 < D.26940) goto <D.21573>; else goto <D.21575>;
  <D.21575>:
  outarg_count.78 = (unsigned int) outarg_count;
  D.26795 = mono_defaults.object_class;
  out_args = mono_array_new (domain, D.26795, outarg_count.78);
  {
    size_t __s1_len;
    size_t __s2_len;

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

      D.26945 = method->method;
      __s2 = D.26945->name;
      D.26946 = ".ctor";
      D.26947 = MEM[(const unsigned char *)D.26946];
      D.26948 = (int) D.26947;
      D.26949 = *__s2;
      D.26950 = (int) D.26949;
      __result = D.26948 - D.26950;
      {
        D.26951 = __s2_len != 0;
        D.26952 = __result == 0;
        D.26953 = D.26951 & D.26952;
        if (D.26953 != 0) goto <D.26954>; else goto <D.26955>;
        <D.26954>:
        D.26956 = &MEM[(void *)".ctor" + 1B];
        D.26957 = *D.26956;
        D.26958 = (int) D.26957;
        D.26959 = __s2 + 1;
        D.26960 = *D.26959;
        D.26961 = (int) D.26960;
        __result = D.26958 - D.26961;
        D.26962 = __s2_len > 1;
        D.26952 = __result == 0;
        D.26963 = D.26962 & D.26952;
        if (D.26963 != 0) goto <D.26964>; else goto <D.26965>;
        <D.26964>:
        D.26966 = &MEM[(void *)".ctor" + 2B];
        D.26967 = *D.26966;
        D.26968 = (int) D.26967;
        D.26969 = __s2 + 2;
        D.26970 = *D.26969;
        D.26971 = (int) D.26970;
        __result = D.26968 - D.26971;
        D.26972 = __s2_len > 2;
        D.26952 = __result == 0;
        D.26973 = D.26972 & D.26952;
        if (D.26973 != 0) goto <D.26974>; else goto <D.26975>;
        <D.26974>:
        D.26976 = &MEM[(void *)".ctor" + 3B];
        D.26977 = *D.26976;
        D.26978 = (int) D.26977;
        D.26979 = __s2 + 3;
        D.26980 = *D.26979;
        D.26981 = (int) D.26980;
        __result = D.26978 - D.26981;
        <D.26975>:
        <D.26965>:
        <D.26955>:
      }
      D.21583 = __result;
    }
    iftmp.79 = -D.21583;
    goto <D.26982>;
    <D.26944>:
    D.26945 = method->method;
    D.26983 = D.26945->name;
    iftmp.79 = __builtin_strcmp (D.26983, ".ctor");
    <D.26982>:
    D.21584 = iftmp.79;
  }
  if (D.21584 == 0) goto <D.26984>; else goto <D.26985>;
  <D.26984>:
  D.26846 = this == 0B;
  D.26847 = (long int) D.26846;
  D.26848 = __builtin_expect (D.26847, 0);
  if (D.26848 != 0) goto <D.26986>; else goto <D.26987>;
  <D.26986>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "icall.c", 2955, "this");
  <D.26987>:
  <D.26985>:
  D.26945 = method->method;
  D.26988 = D.26945->klass;
  D.26989 = BIT_FIELD_REF <*D.26988, 8, 160>;
  D.26990 = D.26989 & 8;
  D.26991 = D.26990 != 0;
  D.26992 = (long int) D.26991;
  D.26993 = __builtin_expect (D.26992, 0);
  if (D.26993 != 0) goto <D.26994>; else goto <D.26995>;
  <D.26994>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "icall.c", 2958, "!method->method->klass->valuetype");
  <D.26995>:
  D.26945 = method->method;
  result = mono_runtime_invoke_array (D.26945, this, params, 0B);
  i = 0;
  j = 0;
  goto <D.21588>;
  <D.21587>:
  D.26934 = sig->params[i];
  D.26935 = BIT_FIELD_REF <*D.26934, 8, 56>;
  D.26936 = D.26935 & 64;
  if (D.26936 != 0) goto <D.26996>; else goto <D.26997>;
  <D.26996>:
  {
    void * arg;

    i.77 = (unsigned int) i;
    D.26998 = mono_array_addr_with_size (params, 4, i.77);
    arg = MEM[(void * *)D.26998];
    {
      void * * __p;

      j.80 = (unsigned int) j;
      __p = mono_array_addr_with_size (out_args, 4, j.80);
      mono_gc_wbarrier_set_arrayref (out_args, __p, arg);
    }
    j = j + 1;
  }
  <D.26997>:
  i = i + 1;
  <D.21588>:
  i.77 = (unsigned int) i;
  D.27000 = mono_array_length (params);
  if (i.77 < D.27000) goto <D.21587>; else goto <D.21589>;
  <D.21589>:
  mono_gc_wbarrier_generic_store (outArgs, out_args);
  D.26864 = result;
  return D.26864;
}


ves_icall_Remoting_RemotingServices_GetVirtualMethod (struct MonoReflectionType * rtype, struct MonoReflectionMethod * rmethod)
{
  _Bool D.27003;
  long int D.27004;
  long int D.27005;
  _Bool D.27010;
  long int D.27011;
  long int D.27012;
  struct MonoType * D.27017;
  unsigned int D.27020;
  unsigned int D.27021;
  unsigned char D.27023;
  struct MonoReflectionMethod * D.27025;
  short unsigned int D.27026;
  int D.27027;
  int D.27028;
  unsigned int D.27031;
  unsigned int D.27032;
  struct MonoClass * D.27037;
  int D.27039;
  unsigned int D.27040;
  unsigned int D.27041;
  short int D.27046;
  int D.27047;
  int D.27048;
  unsigned int D.27049;
  unsigned int D.27050;
  struct MonoMethod * * D.27051;
  int D.27055;
  unsigned int D.27060;
  unsigned int D.27061;
  struct MonoMethod * * D.27062;
  struct MonoDomain * D.27065;
  struct MonoClass * klass;
  struct MonoMethod * method;
  struct MonoMethod * * vtable;
  struct MonoMethod * res;

  res = 0B;
  D.27003 = rtype == 0B;
  D.27004 = (long int) D.27003;
  D.27005 = __builtin_expect (D.27004, 0);
  if (D.27005 != 0) goto <D.27006>; else goto <D.27007>;
  <D.27006>:
  {
    struct MonoException * ex;

    if (rtype != 0B) goto <D.27008>; else goto <D.27009>;
    <D.27008>:
    <D.27009>:
    ex = mono_get_exception_argument_null ("rtype");
    mono_raise_exception (ex);
  }
  <D.27007>:
  D.27010 = rmethod == 0B;
  D.27011 = (long int) D.27010;
  D.27012 = __builtin_expect (D.27011, 0);
  if (D.27012 != 0) goto <D.27013>; else goto <D.27014>;
  <D.27013>:
  {
    struct MonoException * ex;

    if (rmethod != 0B) goto <D.27015>; else goto <D.27016>;
    <D.27015>:
    <D.27016>:
    ex = mono_get_exception_argument_null ("rmethod");
    mono_raise_exception (ex);
  }
  <D.27014>:
  method = rmethod->method;
  D.27017 = rtype->type;
  klass = mono_class_from_mono_type (D.27017);
  mono_class_init_or_throw (klass);
  D.27020 = klass->flags;
  D.27021 = D.27020 & 32;
  if (D.27021 != 0) goto <D.27018>; else goto <D.27022>;
  <D.27022>:
  D.27023 = klass->byval_arg.type;
  if (D.27023 == 19) goto <D.27018>; else goto <D.27024>;
  <D.27024>:
  D.27023 = klass->byval_arg.type;
  if (D.27023 == 30) goto <D.27018>; else goto <D.27019>;
  <D.27018>:
  D.27025 = 0B;
  return D.27025;
  <D.27019>:
  D.27026 = method->flags;
  D.27027 = (int) D.27026;
  D.27028 = D.27027 & 16;
  if (D.27028 != 0) goto <D.27029>; else goto <D.27030>;
  <D.27029>:
  D.27025 = 0B;
  return D.27025;
  <D.27030>:
  D.27026 = method->flags;
  D.27031 = (unsigned int) D.27026;
  D.27032 = D.27031 & 96;
  if (D.27032 != 64) goto <D.27033>; else goto <D.27034>;
  <D.27033>:
  D.27037 = method->klass;
  if (D.27037 == klass) goto <D.27035>; else goto <D.27038>;
  <D.27038>:
  D.27037 = method->klass;
  D.27039 = mono_class_is_subclass_of (klass, D.27037, 0);
  if (D.27039 != 0) goto <D.27035>; else goto <D.27036>;
  <D.27035>:
  D.27025 = rmethod;
  return D.27025;
  <D.27036>:
  D.27025 = 0B;
  return D.27025;
  <D.27034>:
  mono_class_setup_vtable (klass);
  vtable = klass->vtable;
  D.27037 = method->klass;
  D.27040 = D.27037->flags;
  D.27041 = D.27040 & 32;
  if (D.27041 != 0) goto <D.27042>; else goto <D.27043>;
  <D.27042>:
  {
    gboolean variance_used;
    int offs;

    try
      {
        variance_used = 0;
        D.27037 = method->klass;
        offs = mono_class_interface_offset_with_variance (klass, D.27037, &variance_used);
        if (offs >= 0) goto <D.27044>; else goto <D.27045>;
        <D.27044>:
        D.27046 = method->slot;
        D.27047 = (int) D.27046;
        D.27048 = D.27047 + offs;
        D.27049 = (unsigned int) D.27048;
        D.27050 = D.27049 * 4;
        D.27051 = vtable + D.27050;
        res = *D.27051;
        <D.27045>:
      }
    finally
      {
        variance_used = {CLOBBER};
      }
  }
  goto <D.27052>;
  <D.27043>:
  D.27037 = method->klass;
  if (D.27037 != klass) goto <D.27053>; else goto <D.27054>;
  <D.27053>:
  D.27037 = method->klass;
  D.27055 = mono_class_is_subclass_of (klass, D.27037, 0);
  if (D.27055 == 0) goto <D.27056>; else goto <D.27057>;
  <D.27056>:
  D.27025 = 0B;
  return D.27025;
  <D.27057>:
  <D.27054>:
  D.27046 = method->slot;
  if (D.27046 != -1) goto <D.27058>; else goto <D.27059>;
  <D.27058>:
  D.27046 = method->slot;
  D.27060 = (unsigned int) D.27046;
  D.27061 = D.27060 * 4;
  D.27062 = vtable + D.27061;
  res = *D.27062;
  <D.27059>:
  <D.27052>:
  if (res == 0B) goto <D.27063>; else goto <D.27064>;
  <D.27063>:
  D.27025 = 0B;
  return D.27025;
  <D.27064>:
  D.27065 = mono_domain_get ();
  D.27025 = mono_method_get_object (D.27065, res, 0B);
  return D.27025;
}


ves_icall_Remoting_RealProxy_GetTransparentProxy (struct MonoObject * this, struct MonoString * class_name)
{
  struct MonoVTable * D.27067;
  struct MonoClass * D.27068;
  struct MonoRealProxy * * D.27069;
  struct MonoReflectionType * D.27070;
  struct MonoClass * D.27071;
  struct MonoObject * D.27072;
  _Bool D.27073;
  unsigned char D.27074;
  struct MonoRemoteClass * D.27075;
  struct MonoRemoteClass * D.27076;
  void * D.27077;
  struct MonoObject * D.27078;
  struct MonoDomain * domain;
  struct MonoObject * res;
  struct MonoRealProxy * rp;
  struct MonoTransparentProxy * tp;
  struct MonoType * type;
  struct MonoClass * klass;

  D.27067 = this->vtable;
  domain = D.27067->domain;
  rp = this;
  D.27068 = mono_defaults.transparent_proxy_class;
  res = mono_object_new (domain, D.27068);
  tp = res;
  D.27069 = &tp->rp;
  mono_gc_wbarrier_set_field (tp, D.27069, rp);
  D.27070 = rp->class_to_proxy;
  type = D.27070->type;
  klass = mono_class_from_mono_type (type);
  D.27071 = mono_defaults.iremotingtypeinfo_class;
  D.27072 = mono_object_isinst (this, D.27071);
  D.27073 = D.27072 != 0B;
  D.27074 = (unsigned char) D.27073;
  tp->custom_type_info = D.27074;
  D.27075 = mono_remote_class (domain, class_name, klass);
  tp->remote_class = D.27075;
  D.27076 = tp->remote_class;
  D.27077 = mono_remote_class_vtable (domain, D.27076, rp);
  res->vtable = D.27077;
  D.27078 = res;
  return D.27078;
}


ves_icall_Remoting_RealProxy_InternalGetProxyType (struct MonoTransparentProxy * tp)
{
  struct MonoReflectionType * D.27080;
  struct MonoRemoteClass * D.27081;
  struct MonoClass * D.27082;
  struct MonoType * D.27083;
  struct MonoVTable * D.27084;
  struct MonoDomain * D.27085;

  D.27081 = tp->remote_class;
  D.27082 = D.27081->proxy_class;
  D.27083 = &D.27082->byval_arg;
  D.27084 = MEM[(struct MonoObject *)tp].vtable;
  D.27085 = D.27084->domain;
  D.27080 = mono_type_get_object (D.27085, D.27083);
  return D.27080;
}


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

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


ves_icall_System_Runtime_Activation_ActivationServices_EnableProxyActivation (struct MonoReflectionType * type, MonoBoolean enable)
{
  struct MonoType * D.27089;
  struct MonoDomain * D.27090;
  _Bool D.27091;
  struct MonoClass * klass;
  struct MonoVTable * vtable;

  D.27089 = type->type;
  klass = mono_class_from_mono_type (D.27089);
  D.27090 = mono_domain_get ();
  vtable = mono_class_vtable_full (D.27090, klass, 1);
  D.27091 = enable != 0;
  vtable->remote = D.27091;
}


ves_icall_System_Runtime_Activation_ActivationServices_AllocateUninitializedClassInstance (struct MonoReflectionType * type)
{
  struct MonoVTable * D.27092;
  struct MonoType * D.27093;
  unsigned int D.27096;
  unsigned int D.27097;
  unsigned char D.27099;
  unsigned int D.27102;
  struct MonoException * D.27103;
  unsigned char D.27104;
  _Bool D.27107;
  long int D.27108;
  long int D.27109;
  struct MonoObject * D.27112;
  struct MonoClass * D.27113;
  struct MonoVTable * D.27114;
  struct MonoClass * klass;
  struct MonoDomain * domain;

  D.27092 = MEM[(struct MonoObject *)type].vtable;
  domain = D.27092->domain;
  D.27093 = type->type;
  klass = mono_class_from_mono_type (D.27093);
  mono_class_init_or_throw (klass);
  D.27096 = klass->flags;
  D.27097 = D.27096 & 32;
  if (D.27097 != 0) goto <D.27094>; else goto <D.27098>;
  <D.27098>:
  D.27099 = klass->byval_arg.type;
  if (D.27099 == 19) goto <D.27094>; else goto <D.27100>;
  <D.27100>:
  D.27099 = klass->byval_arg.type;
  if (D.27099 == 30) goto <D.27094>; else goto <D.27101>;
  <D.27101>:
  D.27096 = klass->flags;
  D.27102 = D.27096 & 128;
  if (D.27102 != 0) goto <D.27094>; else goto <D.27095>;
  <D.27094>:
  D.27103 = mono_get_exception_argument ("type", "Type cannot be instantiated");
  mono_raise_exception (D.27103);
  <D.27095>:
  D.27104 = klass->rank;
  if (D.27104 != 0) goto <D.27105>; else goto <D.27106>;
  <D.27105>:
  D.27104 = klass->rank;
  D.27107 = D.27104 != 1;
  D.27108 = (long int) D.27107;
  D.27109 = __builtin_expect (D.27108, 0);
  if (D.27109 != 0) goto <D.27110>; else goto <D.27111>;
  <D.27110>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "icall.c", 6838, "klass->rank == 1");
  <D.27111>:
  D.27113 = klass->element_class;
  D.27112 = mono_array_new (domain, D.27113, 0);
  return D.27112;
  <D.27106>:
  D.27114 = mono_class_vtable_full (domain, klass, 1);
  D.27112 = mono_object_new_alloc_specific (D.27114);
  return D.27112;
}


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

  try
    {
      D.27116 = type->type;
      klass = mono_class_from_mono_type (D.27116);
      iter = 0B;
      mono_class_init_or_throw (klass);
      goto <D.23138>;
      <D.23137>:
      prelink_method (m);
      <D.23138>:
      m = mono_class_get_methods (klass, &iter);
      if (m != 0B) goto <D.23137>; else goto <D.23139>;
      <D.23139>:
    }
  finally
    {
      iter = {CLOBBER};
    }
}


prelink_method (struct MonoMethod * method)
{
  short unsigned int D.27117;
  int D.27118;
  int D.27119;
  const char * exc_class.81;
  const char * exc_arg.82;
  struct MonoImage * D.27126;
  struct MonoException * D.27127;
  const char * exc_class;
  const char * exc_arg;

  try
    {
      D.27117 = method->flags;
      D.27118 = (int) D.27117;
      D.27119 = D.27118 & 8192;
      if (D.27119 == 0) goto <D.27120>; else goto <D.27121>;
      <D.27120>:
      return;
      <D.27121>:
      mono_lookup_pinvoke_call (method, &exc_class, &exc_arg);
      exc_class.81 = exc_class;
      if (exc_class.81 != 0B) goto <D.27123>; else goto <D.27124>;
      <D.27123>:
      exc_arg.82 = exc_arg;
      exc_class.81 = exc_class;
      D.27126 = mono_defaults.corlib;
      D.27127 = mono_exception_from_name_msg (D.27126, "System", exc_class.81, exc_arg.82);
      mono_raise_exception (D.27127);
      <D.27124>:
    }
  finally
    {
      exc_class = {CLOBBER};
      exc_arg = {CLOBBER};
    }
}


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

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


ves_icall_System_Runtime_CompilerServices_RuntimeHelpers_SufficientExecutionStack ()
{
  guint8 * stack_addr.83;
  MonoBoolean D.27135;
  int current.84;
  int stack_addr.85;
  int D.27140;
  unsigned int stack_size.86;
  sizetype D.27145;
  guint8 * D.27146;
  int D.27147;
  int D.27148;
  guint8 * stack_addr;
  guint8 * current;
  size_t stack_size;
  int min_size;

  try
    {
      min_size = 65536;
      mono_thread_get_stack_bounds (&stack_addr, &stack_size);
      stack_addr.83 = stack_addr;
      if (stack_addr.83 == 0B) goto <D.27133>; else goto <D.27134>;
      <D.27133>:
      D.27135 = 1;
      return D.27135;
      <D.27134>:
      current = &stack_addr;
      stack_addr.83 = stack_addr;
      if (current > stack_addr.83) goto <D.27136>; else goto <D.27137>;
      <D.27136>:
      current.84 = (int) current;
      stack_addr.83 = stack_addr;
      stack_addr.85 = (int) stack_addr.83;
      D.27140 = current.84 - stack_addr.85;
      if (D.27140 < min_size) goto <D.27141>; else goto <D.27142>;
      <D.27141>:
      D.27135 = 0;
      return D.27135;
      <D.27142>:
      goto <D.27143>;
      <D.27137>:
      current.84 = (int) current;
      stack_addr.83 = stack_addr;
      stack_size.86 = stack_size;
      D.27145 = -stack_size.86;
      D.27146 = stack_addr.83 + D.27145;
      D.27147 = (int) D.27146;
      D.27148 = current.84 - D.27147;
      if (D.27148 < min_size) goto <D.27149>; else goto <D.27150>;
      <D.27149>:
      D.27135 = 0;
      return D.27135;
      <D.27150>:
      <D.27143>:
      D.27135 = 1;
      return D.27135;
    }
  finally
    {
      stack_addr = {CLOBBER};
      stack_size = {CLOBBER};
    }
}


ves_icall_System_Runtime_CompilerServices_RuntimeHelpers_RunModuleConstructor (struct MonoImage * image)
{
  unsigned char D.27153;
  unsigned char D.27154;
  struct MonoDomain * D.27157;
  struct MonoVTable * D.27158;

  mono_image_check_for_module_cctor (image);
  D.27153 = BIT_FIELD_REF <*image, 8, 128>;
  D.27154 = D.27153 & 128;
  if (D.27154 != 0) goto <D.27155>; else goto <D.27156>;
  <D.27155>:
  {
    struct MonoClass * module_klass;

    module_klass = mono_class_get (image, 33554433);
    D.27157 = mono_domain_get ();
    D.27158 = mono_class_vtable_full (D.27157, module_klass, 1);
    mono_runtime_class_init (D.27158);
  }
  <D.27156>:
}


ves_icall_System_Runtime_CompilerServices_RuntimeHelpers_RunClassConstructor (struct MonoType * handle)
{
  _Bool D.27159;
  long int D.27160;
  long int D.27161;
  _Bool D.27166;
  long int D.27167;
  long int D.27168;
  struct MonoDomain * D.27173;
  struct MonoClass * klass;
  struct MonoVTable * vtable;

  D.27159 = handle == 0B;
  D.27160 = (long int) D.27159;
  D.27161 = __builtin_expect (D.27160, 0);
  if (D.27161 != 0) goto <D.27162>; else goto <D.27163>;
  <D.27162>:
  {
    struct MonoException * ex;

    if (handle != 0B) goto <D.27164>; else goto <D.27165>;
    <D.27164>:
    <D.27165>:
    ex = mono_get_exception_argument_null ("handle");
    mono_raise_exception (ex);
  }
  <D.27163>:
  klass = mono_class_from_mono_type (handle);
  D.27166 = klass == 0B;
  D.27167 = (long int) D.27166;
  D.27168 = __builtin_expect (D.27167, 0);
  if (D.27168 != 0) goto <D.27169>; else goto <D.27170>;
  <D.27169>:
  {
    struct MonoException * ex;
    char * msg;

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


ves_icall_System_Runtime_CompilerServices_RuntimeHelpers_InitializeArray (struct MonoArray * array, struct MonoClassField * field_handle)
{
  struct MonoVTable * D.27174;
  int D.27175;
  struct MonoClass * D.27176;
  struct MonoType * D.27177;
  int D.27180;
  unsigned char D.27182;
  struct MonoType * D.27183;
  short unsigned int D.27184;
  int D.27185;
  int D.27186;
  unsigned int D.27189;
  int D.27190;
  unsigned int D.27191;
  char * D.27194;
  struct MonoClass * klass;
  guint32 size;
  struct MonoType * type;
  int align;
  const char * field_data;

  try
    {
      D.27174 = array->obj.vtable;
      klass = D.27174->klass;
      D.27175 = mono_array_element_size (klass);
      size = (guint32) D.27175;
      D.27176 = klass->element_class;
      D.27177 = &D.27176->byval_arg;
      type = mono_type_get_underlying_type (D.27177);
      D.27180 = mono_type_is_reference (type);
      if (D.27180 != 0) goto <D.27178>; else goto <D.27181>;
      <D.27181>:
      D.27182 = type->type;
      if (D.27182 == 17) goto <D.27178>; else goto <D.27179>;
      <D.27178>:
      {
        struct MonoException * exc;

        exc = mono_get_exception_argument ("array", "Cannot initialize array of non-primitive type.");
        mono_raise_exception (exc);
      }
      <D.27179>:
      D.27183 = field_handle->type;
      D.27184 = D.27183->attrs;
      D.27185 = (int) D.27184;
      D.27186 = D.27185 & 256;
      if (D.27186 == 0) goto <D.27187>; else goto <D.27188>;
      <D.27187>:
      {
        struct MonoException * exc;

        exc = mono_get_exception_argument ("field_handle", "Field doesn\'t have an RVA");
        mono_raise_exception (exc);
      }
      <D.27188>:
      D.27189 = array->max_length;
      size = D.27189 * size;
      field_data = mono_field_get_data (field_handle);
      D.27183 = field_handle->type;
      D.27190 = mono_type_size (D.27183, &align);
      D.27191 = (unsigned int) D.27190;
      if (D.27191 < size) goto <D.27192>; else goto <D.27193>;
      <D.27192>:
      {
        struct MonoException * exc;

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


ves_icall_System_Runtime_CompilerServices_RuntimeHelpers_GetOffsetToStringData ()
{
  gint D.27195;

  D.27195 = 12;
  return D.27195;
}


ves_icall_System_Runtime_CompilerServices_RuntimeHelpers_GetObjectValue (struct MonoObject * obj)
{
  struct MonoVTable * D.27200;
  struct MonoClass * D.27201;
  unsigned char D.27202;
  unsigned char D.27203;
  struct MonoObject * D.27204;

  if (obj == 0B) goto <D.27197>; else goto <D.27199>;
  <D.27199>:
  D.27200 = obj->vtable;
  D.27201 = D.27200->klass;
  D.27202 = BIT_FIELD_REF <*D.27201, 8, 160>;
  D.27203 = D.27202 & 8;
  if (D.27203 == 0) goto <D.27197>; else goto <D.27198>;
  <D.27197>:
  D.27204 = obj;
  return D.27204;
  <D.27198>:
  D.27204 = mono_object_clone (obj);
  return D.27204;
}


param_info_get_type_modifiers (struct MonoReflectionParameter * param, MonoBoolean optional)
{
  struct MonoReflectionType * D.27206;
  struct MonoObject * D.27207;
  struct MonoVTable * D.27208;
  int D.27209;
  struct MonoImage * D.27215;
  struct MonoImage * D.27216;
  int D.23202;
  int iftmp.87;
  int D.23198;
  const char[13] * D.27221;
  unsigned char D.27222;
  int D.27223;
  unsigned char D.27224;
  int D.27225;
  _Bool D.27226;
  _Bool D.27227;
  _Bool D.27228;
  const unsigned char * D.27231;
  unsigned char D.27232;
  int D.27233;
  const unsigned char * D.27234;
  unsigned char D.27235;
  int D.27236;
  _Bool D.27237;
  _Bool D.27238;
  const unsigned char * D.27241;
  unsigned char D.27242;
  int D.27243;
  const unsigned char * D.27244;
  unsigned char D.27245;
  int D.27246;
  _Bool D.27247;
  _Bool D.27248;
  const unsigned char * D.27251;
  unsigned char D.27252;
  int D.27253;
  const unsigned char * D.27254;
  unsigned char D.27255;
  int D.27256;
  const char * D.27258;
  struct MonoProperty * D.27260;
  _Bool D.27263;
  long int D.27264;
  long int D.27265;
  struct MonoClass * D.27268;
  struct MonoArray * D.27272;
  int D.27273;
  struct MonoType * type;
  struct MonoClass * member_class;
  struct MonoMethod * method;
  struct MonoImage * image;
  int pos;
  struct MonoMethodSignature * sig;

  D.27206 = param->ClassImpl;
  type = D.27206->type;
  D.27207 = param->MemberImpl;
  D.27208 = D.27207->vtable;
  member_class = D.27208->klass;
  method = 0B;
  D.27209 = mono_class_is_reflection_method_or_constructor (member_class);
  if (D.27209 != 0) goto <D.27210>; else goto <D.27211>;
  <D.27210>:
  {
    struct MonoReflectionMethod * rmethod;

    rmethod = param->MemberImpl;
    method = rmethod->method;
  }
  goto <D.27212>;
  <D.27211>:
  D.27215 = member_class->image;
  D.27216 = mono_defaults.corlib;
  if (D.27215 == D.27216) goto <D.27217>; else goto <D.27213>;
  <D.27217>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = member_class->name;
      D.27221 = "MonoProperty";
      D.27222 = MEM[(const unsigned char *)D.27221];
      D.27223 = (int) D.27222;
      D.27224 = *__s2;
      D.27225 = (int) D.27224;
      __result = D.27223 - D.27225;
      {
        D.27226 = __s1_len != 0;
        D.27227 = __result == 0;
        D.27228 = D.27226 & D.27227;
        if (D.27228 != 0) goto <D.27229>; else goto <D.27230>;
        <D.27229>:
        D.27231 = &MEM[(void *)"MonoProperty" + 1B];
        D.27232 = *D.27231;
        D.27233 = (int) D.27232;
        D.27234 = __s2 + 1;
        D.27235 = *D.27234;
        D.27236 = (int) D.27235;
        __result = D.27233 - D.27236;
        D.27237 = __s1_len > 1;
        D.27227 = __result == 0;
        D.27238 = D.27237 & D.27227;
        if (D.27238 != 0) goto <D.27239>; else goto <D.27240>;
        <D.27239>:
        D.27241 = &MEM[(void *)"MonoProperty" + 2B];
        D.27242 = *D.27241;
        D.27243 = (int) D.27242;
        D.27244 = __s2 + 2;
        D.27245 = *D.27244;
        D.27246 = (int) D.27245;
        __result = D.27243 - D.27246;
        D.27247 = __s1_len > 2;
        D.27227 = __result == 0;
        D.27248 = D.27247 & D.27227;
        if (D.27248 != 0) goto <D.27249>; else goto <D.27250>;
        <D.27249>:
        D.27251 = &MEM[(void *)"MonoProperty" + 3B];
        D.27252 = *D.27251;
        D.27253 = (int) D.27252;
        D.27254 = __s2 + 3;
        D.27255 = *D.27254;
        D.27256 = (int) D.27255;
        __result = D.27253 - D.27256;
        <D.27250>:
        <D.27240>:
        <D.27230>:
      }
      D.23198 = __result;
    }
    iftmp.87 = D.23198;
    goto <D.27257>;
    <D.27220>:
    D.27258 = member_class->name;
    iftmp.87 = __builtin_strcmp ("MonoProperty", D.27258);
    <D.27257>:
    D.23202 = iftmp.87;
  }
  if (D.23202 == 0) goto <D.27259>; else goto <D.27213>;
  <D.27259>:
  {
    struct MonoReflectionProperty * prop;

    prop = param->MemberImpl;
    D.27260 = prop->property;
    method = D.27260->get;
    if (method == 0B) goto <D.27261>; else goto <D.27262>;
    <D.27261>:
    D.27260 = prop->property;
    method = D.27260->set;
    <D.27262>:
    D.27263 = method == 0B;
    D.27264 = (long int) D.27263;
    D.27265 = __builtin_expect (D.27264, 0);
    if (D.27265 != 0) goto <D.27266>; else goto <D.27267>;
    <D.27266>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "icall.c", 7444, "method");
    <D.27267>:
  }
  goto <D.27214>;
  <D.27213>:
  {
    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.27214>:
  <D.27212>:
  D.27268 = method->klass;
  image = D.27268->image;
  pos = param->PositionImpl;
  sig = mono_method_signature (method);
  if (pos == -1) goto <D.27269>; else goto <D.27270>;
  <D.27269>:
  type = sig->ret;
  goto <D.27271>;
  <D.27270>:
  type = sig->params[pos];
  <D.27271>:
  D.27273 = (int) optional;
  D.27272 = type_array_from_modifiers (image, type, D.27273);
  return D.27272;
}


type_array_from_modifiers (struct MonoImage * image, struct MonoType * type, int optional)
{
  <unnamed-unsigned:1> D.27279;
  <unnamed-unsigned:6> D.27281;
  int D.27282;
  struct MonoArray * D.27285;
  unsigned int count.88;
  struct MonoClass * D.27287;
  struct MonoDomain * D.27288;
  <unnamed-unsigned:31> D.27294;
  unsigned int D.27295;
  struct MonoType * D.27296;
  struct MonoDomain * D.27297;
  struct MonoReflectionType * D.27298;
  struct MonoArray * res;
  int i;
  int count;

  count = 0;
  i = 0;
  goto <D.23176>;
  <D.23175>:
  if (optional != 0) goto <D.27278>; else goto <D.27275>;
  <D.27278>:
  D.27279 = type->modifiers[i].required;
  if (D.27279 == 0) goto <D.27276>; else goto <D.27275>;
  <D.27275>:
  if (optional == 0) goto <D.27280>; else goto <D.27277>;
  <D.27280>:
  D.27279 = type->modifiers[i].required;
  if (D.27279 != 0) goto <D.27276>; else goto <D.27277>;
  <D.27276>:
  count = count + 1;
  <D.27277>:
  i = i + 1;
  <D.23176>:
  D.27281 = type->num_mods;
  D.27282 = (int) D.27281;
  if (D.27282 > i) goto <D.23175>; else goto <D.23177>;
  <D.23177>:
  if (count == 0) goto <D.27283>; else goto <D.27284>;
  <D.27283>:
  D.27285 = 0B;
  return D.27285;
  <D.27284>:
  count.88 = (unsigned int) count;
  D.27287 = mono_defaults.systemtype_class;
  D.27288 = mono_domain_get ();
  res = mono_array_new (D.27288, D.27287, count.88);
  count = 0;
  i = 0;
  goto <D.23181>;
  <D.23180>:
  if (optional != 0) goto <D.27292>; else goto <D.27289>;
  <D.27292>:
  D.27279 = type->modifiers[i].required;
  if (D.27279 == 0) goto <D.27290>; else goto <D.27289>;
  <D.27289>:
  if (optional == 0) goto <D.27293>; else goto <D.27291>;
  <D.27293>:
  D.27279 = type->modifiers[i].required;
  if (D.27279 != 0) goto <D.27290>; else goto <D.27291>;
  <D.27290>:
  {
    struct MonoClass * klass;

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

      count.88 = (unsigned int) count;
      __p = mono_array_addr_with_size (res, 4, count.88);
      D.27296 = &klass->byval_arg;
      D.27297 = mono_domain_get ();
      D.27298 = mono_type_get_object (D.27297, D.27296);
      mono_gc_wbarrier_set_arrayref (res, __p, D.27298);
    }
    count = count + 1;
  }
  <D.27291>:
  i = i + 1;
  <D.23181>:
  D.27281 = type->num_mods;
  D.27282 = (int) D.27281;
  if (D.27282 > i) goto <D.23180>; else goto <D.23182>;
  <D.23182>:
  D.27285 = res;
  return D.27285;
}


ves_icall_get_property_info (struct MonoReflectionProperty * property, struct MonoPropertyInfo * info, PInfo req_info)
{
  struct MonoVTable * D.27300;
  unsigned int D.27301;
  struct MonoClass * D.27304;
  struct MonoType * D.27305;
  struct MonoReflectionType * D.27306;
  struct MonoReflectionType * * D.27307;
  unsigned int D.27308;
  struct MonoProperty * D.27311;
  struct MonoClass * D.27312;
  struct MonoType * D.27313;
  struct MonoReflectionType * D.27314;
  struct MonoReflectionType * * D.27315;
  unsigned int D.27316;
  const char * D.27319;
  struct MonoString * D.27320;
  struct MonoString * * D.27321;
  unsigned int D.27322;
  unsigned int D.27325;
  unsigned int D.27326;
  struct MonoObject * iftmp.89;
  struct MonoMethod * D.27330;
  struct MonoReflectionMethod * * D.27334;
  unsigned int D.27335;
  struct MonoObject * iftmp.90;
  struct MonoMethod * D.27339;
  struct MonoReflectionMethod * * D.27343;
  struct MonoDomain * domain;

  D.27300 = MEM[(struct MonoObject *)property].vtable;
  domain = D.27300->domain;
  D.27301 = req_info & 8;
  if (D.27301 != 0) goto <D.27302>; else goto <D.27303>;
  <D.27302>:
  D.27304 = property->klass;
  D.27305 = &D.27304->byval_arg;
  D.27306 = mono_type_get_object (domain, D.27305);
  D.27307 = &info->parent;
  mono_gc_wbarrier_generic_store (D.27307, D.27306);
  <D.27303>:
  D.27308 = req_info & 16;
  if (D.27308 != 0) goto <D.27309>; else goto <D.27310>;
  <D.27309>:
  D.27311 = property->property;
  D.27312 = D.27311->parent;
  D.27313 = &D.27312->byval_arg;
  D.27314 = mono_type_get_object (domain, D.27313);
  D.27315 = &info->declaring_type;
  mono_gc_wbarrier_generic_store (D.27315, D.27314);
  <D.27310>:
  D.27316 = req_info & 32;
  if (D.27316 != 0) goto <D.27317>; else goto <D.27318>;
  <D.27317>:
  D.27311 = property->property;
  D.27319 = D.27311->name;
  D.27320 = mono_string_new (domain, D.27319);
  D.27321 = &info->name;
  mono_gc_wbarrier_generic_store (D.27321, D.27320);
  <D.27318>:
  D.27322 = req_info & 1;
  if (D.27322 != 0) goto <D.27323>; else goto <D.27324>;
  <D.27323>:
  D.27311 = property->property;
  D.27325 = D.27311->attrs;
  info->attrs = D.27325;
  <D.27324>:
  D.27326 = req_info & 2;
  if (D.27326 != 0) goto <D.27327>; else goto <D.27328>;
  <D.27327>:
  D.27311 = property->property;
  D.27330 = D.27311->get;
  if (D.27330 != 0B) goto <D.27331>; else goto <D.27332>;
  <D.27331>:
  D.27304 = property->klass;
  D.27311 = property->property;
  D.27330 = D.27311->get;
  iftmp.89 = mono_method_get_object (domain, D.27330, D.27304);
  goto <D.27333>;
  <D.27332>:
  iftmp.89 = 0B;
  <D.27333>:
  D.27334 = &info->get;
  mono_gc_wbarrier_generic_store (D.27334, iftmp.89);
  <D.27328>:
  D.27335 = req_info & 4;
  if (D.27335 != 0) goto <D.27336>; else goto <D.27337>;
  <D.27336>:
  D.27311 = property->property;
  D.27339 = D.27311->set;
  if (D.27339 != 0B) goto <D.27340>; else goto <D.27341>;
  <D.27340>:
  D.27304 = property->klass;
  D.27311 = property->property;
  D.27339 = D.27311->set;
  iftmp.90 = mono_method_get_object (domain, D.27339, D.27304);
  goto <D.27342>;
  <D.27341>:
  iftmp.90 = 0B;
  <D.27342>:
  D.27343 = &info->set;
  mono_gc_wbarrier_generic_store (D.27343, iftmp.90);
  <D.27337>:
}


property_info_get_default_value (struct MonoReflectionProperty * property)
{
  struct MonoVTable * D.27344;
  struct MonoClass * D.27345;
  unsigned int D.27346;
  unsigned int D.27347;
  struct MonoException * D.27350;
  <unnamed type> def_type.91;
  struct MonoObject * D.27352;
  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.27344 = MEM[(struct MonoObject *)property].vtable;
      domain = D.27344->domain;
      D.27345 = prop->parent;
      mono_class_init (D.27345);
      D.27346 = prop->attrs;
      D.27347 = D.27346 & 4096;
      if (D.27347 == 0) goto <D.27348>; else goto <D.27349>;
      <D.27348>:
      D.27350 = mono_get_exception_invalid_operation (0B);
      mono_raise_exception (D.27350);
      <D.27349>:
      def_value = mono_class_get_property_default_value (prop, &def_type);
      def_type.91 = def_type;
      mono_type_from_blob_type (&blob_type, def_type.91, type);
      o = mono_get_object_from_blob (domain, &blob_type, def_value);
      D.27352 = o;
      return D.27352;
    }
  finally
    {
      blob_type = {CLOBBER};
      def_type = {CLOBBER};
    }
}


get_property_type (struct MonoProperty * prop)
{
  struct MonoMethod * D.27355;
  struct MonoType * D.27358;
  struct MonoMethod * D.27359;
  short unsigned int D.27362;
  int D.27363;
  int D.27364;
  struct MonoMethodSignature * sig;

  D.27355 = prop->get;
  if (D.27355 != 0B) goto <D.27356>; else goto <D.27357>;
  <D.27356>:
  D.27355 = prop->get;
  sig = mono_method_signature (D.27355);
  D.27358 = sig->ret;
  return D.27358;
  <D.27357>:
  D.27359 = prop->set;
  if (D.27359 != 0B) goto <D.27360>; else goto <D.27361>;
  <D.27360>:
  D.27359 = prop->set;
  sig = mono_method_signature (D.27359);
  D.27362 = sig->param_count;
  D.27363 = (int) D.27362;
  D.27364 = D.27363 + -1;
  D.27358 = sig->params[D.27364];
  return D.27358;
  <D.27361>:
  D.27358 = 0B;
  return D.27358;
}


mono_type_from_blob_type (struct MonoType * type, MonoTypeEnum blob_type, struct MonoType * real_type)
{
  unsigned char D.27366;
  struct MonoClass * D.27369;
  unsigned char D.27373;
  struct MonoClass * D.27375;
  unsigned char D.27376;
  unsigned char D.27377;
  struct MonoClass * D.27379;
  struct MonoClass * D.27380;

  D.27366 = (unsigned char) blob_type;
  type->type = D.27366;
  type->data.klass = 0B;
  if (blob_type == 18) goto <D.27367>; else goto <D.27368>;
  <D.27367>:
  D.27369 = mono_defaults.object_class;
  type->data.klass = D.27369;
  goto <D.27370>;
  <D.27368>:
  D.27373 = real_type->type;
  if (D.27373 == 17) goto <D.27374>; else goto <D.27371>;
  <D.27374>:
  D.27375 = real_type->data.klass;
  D.27376 = BIT_FIELD_REF <*D.27375, 8, 160>;
  D.27377 = D.27376 & 16;
  if (D.27377 != 0) goto <D.27378>; else goto <D.27371>;
  <D.27378>:
  type->type = 17;
  D.27379 = mono_class_from_mono_type (real_type);
  type->data.klass = D.27379;
  goto <D.27372>;
  <D.27371>:
  D.27380 = mono_class_from_mono_type (real_type);
  type->data.klass = D.27380;
  <D.27372>:
  <D.27370>:
}


property_info_get_type_modifiers (struct MonoReflectionProperty * property, MonoBoolean optional)
{
  struct MonoProperty * D.27381;
  struct MonoClass * D.27382;
  struct MonoArray * D.27385;
  int D.27386;
  struct MonoType * type;
  struct MonoImage * image;

  D.27381 = property->property;
  type = get_property_type (D.27381);
  D.27382 = property->klass;
  image = D.27382->image;
  if (type == 0B) goto <D.27383>; else goto <D.27384>;
  <D.27383>:
  D.27385 = 0B;
  return D.27385;
  <D.27384>:
  D.27386 = (int) optional;
  D.27385 = type_array_from_modifiers (image, type, D.27386);
  return D.27385;
}


ves_icall_System_MonoMethodInfo_get_retval_marshal (struct MonoMethod * method)
{
  struct MonoMethodSignature * D.27388;
  short unsigned int D.27389;
  int D.27390;
  int D.27391;
  unsigned int D.27392;
  unsigned int D.27393;
  struct MonoMarshalSpec * D.27394;
  struct MonoClass * D.27397;
  struct MonoMethodSignature * D.27398;
  short unsigned int D.27399;
  unsigned int i.92;
  unsigned int D.27401;
  struct MonoMarshalSpec * * D.27402;
  struct MonoMarshalSpec * D.27403;
  struct MonoReflectionMarshalAsAttribute * D.27406;
  struct MonoDomain * domain;
  struct MonoReflectionMarshalAsAttribute * res;
  struct MonoMarshalSpec * * mspecs;
  int i;

  domain = mono_domain_get ();
  res = 0B;
  D.27388 = mono_method_signature (method);
  D.27389 = D.27388->param_count;
  D.27390 = (int) D.27389;
  D.27391 = D.27390 + 1;
  D.27392 = (unsigned int) D.27391;
  D.27393 = D.27392 * 4;
  mspecs = monoeg_malloc (D.27393);
  mono_method_get_marshal_info (method, mspecs);
  D.27394 = *mspecs;
  if (D.27394 != 0B) goto <D.27395>; else goto <D.27396>;
  <D.27395>:
  D.27394 = *mspecs;
  D.27397 = method->klass;
  res = mono_reflection_marshal_as_attribute_from_marshal_spec (domain, D.27397, D.27394);
  <D.27396>:
  D.27398 = mono_method_signature (method);
  D.27399 = D.27398->param_count;
  i = (int) D.27399;
  goto <D.21073>;
  <D.21072>:
  i.92 = (unsigned int) i;
  D.27401 = i.92 * 4;
  D.27402 = mspecs + D.27401;
  D.27403 = *D.27402;
  if (D.27403 != 0B) goto <D.27404>; else goto <D.27405>;
  <D.27404>:
  i.92 = (unsigned int) i;
  D.27401 = i.92 * 4;
  D.27402 = mspecs + D.27401;
  D.27403 = *D.27402;
  mono_metadata_free_marshal_spec (D.27403);
  <D.27405>:
  i = i + -1;
  <D.21073>:
  if (i >= 0) goto <D.21072>; else goto <D.21074>;
  <D.21074>:
  monoeg_g_free (mspecs);
  D.27406 = res;
  return D.27406;
}


ves_icall_get_parameter_info (struct MonoMethod * method, struct MonoReflectionMethod * member)
{
  struct MonoArray * D.27408;
  struct MonoClass * iftmp.93;
  struct MonoReflectionType * D.27410;
  struct MonoType * D.27413;
  struct MonoDomain * domain;

  domain = mono_domain_get ();
  D.27410 = member->reftype;
  if (D.27410 != 0B) goto <D.27411>; else goto <D.27412>;
  <D.27411>:
  D.27410 = member->reftype;
  D.27413 = D.27410->type;
  iftmp.93 = mono_class_from_mono_type (D.27413);
  goto <D.27414>;
  <D.27412>:
  iftmp.93 = 0B;
  <D.27414>:
  D.27408 = mono_param_get_objects_internal (domain, method, iftmp.93);
  return D.27408;
}


ves_icall_get_method_info (struct MonoMethod * method, struct MonoMethodInfo * info)
{
  int D.27416;
  struct MonoClass * D.27419;
  struct MonoType * D.27420;
  struct MonoReflectionType * D.27421;
  struct MonoReflectionType * * D.27422;
  struct MonoType * D.27423;
  struct MonoReflectionType * D.27424;
  struct MonoReflectionType * * D.27425;
  short unsigned int D.27426;
  unsigned int D.27427;
  short unsigned int D.27428;
  unsigned int D.27429;
  unsigned char D.27430;
  unsigned char D.27431;
  guint32 iftmp.94;
  short int D.27435;
  unsigned int D.27444;
  <unnamed-unsigned:1> D.27445;
  int D.27446;
  int D.27447;
  <unnamed-unsigned:1> D.27448;
  int D.27449;
  int D.27450;
  int D.27451;
  unsigned int D.27452;
  unsigned int D.27453;
  struct MonoError error;
  struct MonoDomain * domain;
  struct MonoMethodSignature * sig;

  try
    {
      domain = mono_domain_get ();
      sig = mono_method_signature_checked (method, &error);
      D.27416 = mono_error_ok (&error);
      if (D.27416 == 0) goto <D.27417>; else goto <D.27418>;
      <D.27417>:
      mono_error_raise_exception (&error);
      <D.27418>:
      D.27419 = method->klass;
      D.27420 = &D.27419->byval_arg;
      D.27421 = mono_type_get_object (domain, D.27420);
      D.27422 = &info->parent;
      mono_gc_wbarrier_generic_store (D.27422, D.27421);
      D.27423 = sig->ret;
      D.27424 = mono_type_get_object (domain, D.27423);
      D.27425 = &info->ret;
      mono_gc_wbarrier_generic_store (D.27425, D.27424);
      D.27426 = method->flags;
      D.27427 = (unsigned int) D.27426;
      info->attrs = D.27427;
      D.27428 = method->iflags;
      D.27429 = (unsigned int) D.27428;
      info->implattrs = D.27429;
      D.27430 = BIT_FIELD_REF <*sig, 8, 80>;
      D.27431 = D.27430 & 63;
      if (D.27431 == 0) goto <D.27432>; else goto <D.27433>;
      <D.27432>:
      D.27435 = sig->sentinelpos;
      if (D.27435 >= 0) goto <D.27436>; else goto <D.27437>;
      <D.27436>:
      iftmp.94 = 2;
      goto <D.27438>;
      <D.27437>:
      iftmp.94 = 1;
      <D.27438>:
      info->callconv = iftmp.94;
      goto <D.27439>;
      <D.27433>:
      D.27430 = BIT_FIELD_REF <*sig, 8, 80>;
      D.27431 = D.27430 & 63;
      if (D.27431 == 5) goto <D.27440>; else goto <D.27443>;
      <D.27443>:
      D.27435 = sig->sentinelpos;
      if (D.27435 >= 0) goto <D.27440>; else goto <D.27441>;
      <D.27440>:
      info->callconv = 2;
      goto <D.27442>;
      <D.27441>:
      info->callconv = 1;
      <D.27442>:
      <D.27439>:
      D.27444 = info->callconv;
      D.27445 = sig->hasthis;
      D.27446 = (int) D.27445;
      D.27447 = D.27446 << 5;
      D.27448 = sig->explicit_this;
      D.27449 = (int) D.27448;
      D.27450 = D.27449 << 6;
      D.27451 = D.27447 | D.27450;
      D.27452 = (unsigned int) D.27451;
      D.27453 = D.27444 | D.27452;
      info->callconv = D.27453;
    }
  finally
    {
      error = {CLOBBER};
    }
}


vell_icall_get_method_attributes (struct MonoMethod * method)
{
  int D.27454;
  short unsigned int D.27455;

  D.27455 = method->flags;
  D.27454 = (int) D.27455;
  return D.27454;
}


ves_icall_MonoMethod_get_name (struct MonoReflectionMethod * m)
{
  const char * D.27457;
  struct MonoVTable * D.27458;
  struct MonoDomain * D.27459;
  struct MonoString * D.27460;
  struct MonoString * * D.27461;
  struct MonoString * D.27462;
  struct MonoMethod * method;

  method = m->method;
  D.27457 = method->name;
  D.27458 = MEM[(struct MonoObject *)m].vtable;
  D.27459 = D.27458->domain;
  D.27460 = mono_string_new (D.27459, D.27457);
  D.27461 = &m->name;
  mono_gc_wbarrier_set_field (m, D.27461, D.27460);
  D.27462 = m->name;
  return D.27462;
}


ves_icall_MonoMethod_get_base_method (struct MonoReflectionMethod * m, gboolean definition)
{
  struct MonoClass * D.27464;
  struct MonoReflectionMethod * D.27467;
  short unsigned int D.27470;
  int D.27471;
  int D.27472;
  unsigned int D.27474;
  unsigned int D.27475;
  unsigned char D.27477;
  int D.27480;
  struct MonoGenericClass * D.27483;
  int D.27488;
  int D.27495;
  struct MonoMethod * * D.27498;
  unsigned int slot.95;
  unsigned int D.27500;
  struct MonoMethod * * D.27501;
  short int D.27504;
  int D.27505;
  struct MonoDomain * D.27509;
  struct MonoClass * klass;
  struct MonoClass * parent;
  struct MonoMethod * method;
  struct MonoMethod * result;
  int slot;

  method = m->method;
  result = 0B;
  D.27464 = method->klass;
  if (D.27464 == 0B) goto <D.27465>; else goto <D.27466>;
  <D.27465>:
  D.27467 = m;
  return D.27467;
  <D.27466>:
  D.27470 = method->flags;
  D.27471 = (int) D.27470;
  D.27472 = D.27471 & 64;
  if (D.27472 == 0) goto <D.27468>; else goto <D.27473>;
  <D.27473>:
  D.27464 = method->klass;
  D.27474 = D.27464->flags;
  D.27475 = D.27474 & 32;
  if (D.27475 != 0) goto <D.27468>; else goto <D.27476>;
  <D.27476>:
  D.27464 = method->klass;
  D.27477 = D.27464->byval_arg.type;
  if (D.27477 == 19) goto <D.27468>; else goto <D.27478>;
  <D.27478>:
  D.27464 = method->klass;
  D.27477 = D.27464->byval_arg.type;
  if (D.27477 == 30) goto <D.27468>; else goto <D.27479>;
  <D.27479>:
  D.27470 = method->flags;
  D.27471 = (int) D.27470;
  D.27480 = D.27471 & 256;
  if (D.27480 != 0) goto <D.27468>; else goto <D.27469>;
  <D.27468>:
  D.27467 = m;
  return D.27467;
  <D.27469>:
  slot = mono_method_get_vtable_slot (method);
  if (slot == -1) goto <D.27481>; else goto <D.27482>;
  <D.27481>:
  D.27467 = m;
  return D.27467;
  <D.27482>:
  klass = method->klass;
  D.27483 = klass->generic_class;
  if (D.27483 != 0B) goto <D.27484>; else goto <D.27485>;
  <D.27484>:
  D.27483 = klass->generic_class;
  klass = D.27483->container_class;
  <D.27485>:
  if (definition != 0) goto <D.27486>; else goto <D.27487>;
  <D.27486>:
  parent = klass->parent;
  goto <D.23077>;
  <D.23076>:
  mono_class_setup_vtable (parent);
  D.27488 = parent->vtable_size;
  if (D.27488 <= slot) goto <D.23075>; else goto <D.27489>;
  <D.27489>:
  klass = parent;
  parent = parent->parent;
  <D.23077>:
  if (parent != 0B) goto <D.23076>; else goto <D.23075>;
  <D.23075>:
  goto <D.27490>;
  <D.27487>:
  klass = klass->parent;
  if (klass == 0B) goto <D.27491>; else goto <D.27492>;
  <D.27491>:
  D.27467 = m;
  return D.27467;
  <D.27492>:
  <D.27490>:
  D.27464 = method->klass;
  if (D.27464 == klass) goto <D.27493>; else goto <D.27494>;
  <D.27493>:
  D.27467 = m;
  return D.27467;
  <D.27494>:
  D.27495 = klass->vtable_size;
  if (D.27495 <= slot) goto <D.27496>; else goto <D.27497>;
  <D.27496>:
  D.27467 = m;
  return D.27467;
  <D.27497>:
  mono_class_setup_vtable (klass);
  D.27498 = klass->vtable;
  slot.95 = (unsigned int) slot;
  D.27500 = slot.95 * 4;
  D.27501 = D.27498 + D.27500;
  result = *D.27501;
  if (result == 0B) goto <D.27502>; else goto <D.27503>;
  <D.27502>:
  {
    void * iter;

    try
      {
        iter = 0B;
        goto <D.23081>;
        <D.23080>:
        D.27504 = result->slot;
        D.27505 = (int) D.27504;
        if (D.27505 == slot) goto <D.23079>; else goto <D.27506>;
        <D.27506>:
        <D.23081>:
        result = mono_class_get_methods (klass, &iter);
        if (result != 0B) goto <D.23080>; else goto <D.23079>;
        <D.23079>:
      }
    finally
      {
        iter = {CLOBBER};
      }
  }
  <D.27503>:
  if (result == 0B) goto <D.27507>; else goto <D.27508>;
  <D.27507>:
  D.27467 = m;
  return D.27467;
  <D.27508>:
  D.27509 = mono_domain_get ();
  D.27467 = mono_method_get_object (D.27509, result, 0B);
  return D.27467;
}


ves_icall_MonoMethod_get_IsGenericMethodDefinition (struct MonoReflectionMethod * method)
{
  gboolean D.27511;
  struct MonoMethod * D.27512;
  <unnamed-unsigned:1> D.27513;

  D.27512 = method->method;
  D.27513 = D.27512->is_generic;
  D.27511 = (gboolean) D.27513;
  return D.27511;
}


ves_icall_MonoMethod_get_IsGenericMethod (struct MonoReflectionMethod * method)
{
  gboolean D.27515;
  struct MonoMethod * D.27516;
  struct MonoMethodSignature * D.27517;
  short unsigned int D.27518;
  _Bool D.27519;

  D.27516 = method->method;
  D.27517 = mono_method_signature (D.27516);
  D.27518 = D.27517->generic_param_count;
  D.27519 = D.27518 != 0;
  D.27515 = (gboolean) D.27519;
  return D.27515;
}


ves_icall_MonoMethod_GetGenericArguments (struct MonoReflectionMethod * method)
{
  struct MonoVTable * D.27521;
  struct MonoMethod * D.27522;
  unsigned char D.27523;
  unsigned char D.27524;
  struct MonoGenericContext * D.27527;
  <unnamed-unsigned:22> D.27530;
  unsigned int count.96;
  struct MonoClass * D.27532;
  unsigned int i.97;
  struct MonoType * D.27534;
  struct MonoReflectionType * D.27535;
  struct MonoArray * D.27536;
  struct MonoMethodSignature * D.27537;
  short unsigned int D.27538;
  struct MonoGenericParamFull * D.27539;
  unsigned int i.98;
  unsigned int D.27541;
  struct MonoClass * D.27542;
  struct MonoImage * D.27543;
  struct MonoType * D.27544;
  struct MonoReflectionType * D.27545;
  struct MonoArray * res;
  struct MonoDomain * domain;
  int count;
  int i;

  D.27521 = MEM[(struct MonoObject *)method].vtable;
  domain = D.27521->domain;
  D.27522 = method->method;
  D.27523 = BIT_FIELD_REF <*D.27522, 8, 168>;
  D.27524 = D.27523 & 16;
  if (D.27524 != 0) goto <D.27525>; else goto <D.27526>;
  <D.27525>:
  {
    struct MonoGenericInst * inst;

    D.27522 = method->method;
    D.27527 = mono_method_get_context (D.27522);
    inst = D.27527->method_inst;
    if (inst != 0B) goto <D.27528>; else goto <D.27529>;
    <D.27528>:
    D.27530 = inst->type_argc;
    count = (int) D.27530;
    count.96 = (unsigned int) count;
    D.27532 = mono_defaults.systemtype_class;
    res = mono_array_new (domain, D.27532, count.96);
    i = 0;
    goto <D.21465>;
    <D.21464>:
    {
      void * * __p;

      i.97 = (unsigned int) i;
      __p = mono_array_addr_with_size (res, 4, i.97);
      D.27534 = inst->type_argv[i];
      D.27535 = mono_type_get_object (domain, D.27534);
      mono_gc_wbarrier_set_arrayref (res, __p, D.27535);
    }
    i = i + 1;
    <D.21465>:
    if (i < count) goto <D.21464>; else goto <D.21466>;
    <D.21466>:
    D.27536 = res;
    return D.27536;
    <D.27529>:
  }
  <D.27526>:
  D.27522 = method->method;
  D.27537 = mono_method_signature (D.27522);
  D.27538 = D.27537->generic_param_count;
  count = (int) D.27538;
  count.96 = (unsigned int) count;
  D.27532 = mono_defaults.systemtype_class;
  res = mono_array_new (domain, D.27532, count.96);
  i = 0;
  goto <D.21472>;
  <D.21471>:
  {
    struct MonoGenericContainer * container;
    struct MonoGenericParam * param;
    struct MonoClass * pklass;

    D.27522 = method->method;
    container = mono_method_get_generic_container (D.27522);
    D.27539 = container->type_params;
    i.98 = (unsigned int) i;
    D.27541 = i.98 * 32;
    param = D.27539 + D.27541;
    D.27522 = method->method;
    D.27542 = D.27522->klass;
    D.27543 = D.27542->image;
    pklass = mono_class_from_generic_parameter (param, D.27543, 1);
    {
      void * * __p;

      i.97 = (unsigned int) i;
      __p = mono_array_addr_with_size (res, 4, i.97);
      D.27544 = &pklass->byval_arg;
      D.27545 = mono_type_get_object (domain, D.27544);
      mono_gc_wbarrier_set_arrayref (res, __p, D.27545);
    }
  }
  i = i + 1;
  <D.21472>:
  if (i < count) goto <D.21471>; else goto <D.21473>;
  <D.21473>:
  D.27536 = res;
  return D.27536;
}


ves_icall_MonoMethod_GetDllImportAttribute (struct MonoMethod * method)
{
  struct MonoClass * D.27547;
  short unsigned int D.27548;
  int D.27549;
  int D.27550;
  struct MonoReflectionDllImportAttribute * D.27553;
  struct MonoClass * DllImportAttributeClass.99;
  struct MonoImage * D.27557;
  struct MonoClass * DllImportAttributeClass.100;
  _Bool D.27559;
  long int D.27560;
  long int D.27561;
  struct MonoImage * D.27564;
  unsigned char D.27565;
  unsigned char D.27566;
  struct GHashTable * D.27569;
  _Bool D.27572;
  _Bool D.27573;
  _Bool D.27574;
  struct MonoException * D.27577;
  short unsigned int D.27579;
  int D.27582;
  int D.27583;
  unsigned int D.27584;
  short unsigned int D.27585;
  unsigned int D.27586;
  unsigned int D.27587;
  unsigned int D.27588;
  int D.27589;
  short unsigned int D.27590;
  struct MonoString * D.27591;
  struct MonoString * * D.27592;
  struct MonoString * D.27593;
  struct MonoString * * D.27594;
  unsigned int D.27595;
  unsigned int D.27596;
  int D.27597;
  unsigned int D.27598;
  unsigned int D.27599;
  unsigned int D.27600;
  int D.27601;
  int D.27602;
  unsigned int D.27605;
  _Bool D.27606;
  unsigned char D.27607;
  unsigned int D.27608;
  _Bool D.27609;
  unsigned char D.27610;
  unsigned int D.27611;
  _Bool D.27612;
  unsigned char D.27613;
  unsigned int D.27614;
  _Bool D.27615;
  unsigned char D.27616;
  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.27547 = method->klass;
      image = D.27547->image;
      piinfo = method;
      tables = &image->tables;
      im = tables + 336;
      mr = tables + 312;
      import = 0B;
      scope = 0B;
      D.27548 = method->flags;
      D.27549 = (int) D.27548;
      D.27550 = D.27549 & 8192;
      if (D.27550 == 0) goto <D.27551>; else goto <D.27552>;
      <D.27551>:
      D.27553 = 0B;
      return D.27553;
      <D.27552>:
      DllImportAttributeClass.99 = DllImportAttributeClass;
      if (DllImportAttributeClass.99 == 0B) goto <D.27555>; else goto <D.27556>;
      <D.27555>:
      D.27557 = mono_defaults.corlib;
      DllImportAttributeClass.100 = mono_class_from_name (D.27557, "System.Runtime.InteropServices", "DllImportAttribute");
      DllImportAttributeClass = DllImportAttributeClass.100;
      DllImportAttributeClass.99 = DllImportAttributeClass;
      D.27559 = DllImportAttributeClass.99 == 0B;
      D.27560 = (long int) D.27559;
      D.27561 = __builtin_expect (D.27560, 0);
      if (D.27561 != 0) goto <D.27562>; else goto <D.27563>;
      <D.27562>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "icall.c", 2598, "DllImportAttributeClass");
      <D.27563>:
      <D.27556>:
      D.27547 = method->klass;
      D.27564 = D.27547->image;
      D.27565 = BIT_FIELD_REF <*D.27564, 8, 128>;
      D.27566 = D.27565 & 8;
      if (D.27566 != 0) goto <D.27567>; else goto <D.27568>;
      <D.27567>:
      {
        struct MonoReflectionMethodAux * method_aux;

        D.27547 = method->klass;
        D.27564 = D.27547->image;
        D.27569 = MEM[(struct MonoDynamicImage *)D.27564].method_aux_hash;
        method_aux = monoeg_g_hash_table_lookup (D.27569, method);
        if (method_aux != 0B) goto <D.27570>; else goto <D.27571>;
        <D.27570>:
        import = method_aux->dllentry;
        scope = method_aux->dll;
        <D.27571>:
        D.27572 = import == 0B;
        D.27573 = scope == 0B;
        D.27574 = D.27572 | D.27573;
        if (D.27574 != 0) goto <D.27575>; else goto <D.27576>;
        <D.27575>:
        D.27577 = mono_get_exception_argument ("method", "System.Reflection.Emit method with invalid pinvoke information");
        mono_raise_exception (D.27577);
        D.27553 = 0B;
        return D.27553;
        <D.27576>:
      }
      goto <D.27578>;
      <D.27568>:
      D.27579 = piinfo->implmap_idx;
      if (D.27579 != 0) goto <D.27580>; else goto <D.27581>;
      <D.27580>:
      D.27579 = piinfo->implmap_idx;
      D.27582 = (int) D.27579;
      D.27583 = D.27582 + -1;
      mono_metadata_decode_row (im, D.27583, &im_cols, 4);
      D.27584 = im_cols[0];
      D.27585 = (short unsigned int) D.27584;
      piinfo->piflags = D.27585;
      D.27586 = im_cols[2];
      import = mono_metadata_string_heap (image, D.27586);
      D.27587 = im_cols[3];
      D.27588 = D.27587 + 4294967295;
      D.27589 = (int) D.27588;
      scope_token = mono_metadata_decode_row_col (mr, D.27589, 0);
      scope = mono_metadata_string_heap (image, scope_token);
      <D.27581>:
      <D.27578>:
      D.27590 = piinfo->piflags;
      flags = (guint32) D.27590;
      DllImportAttributeClass.99 = DllImportAttributeClass;
      attr = mono_object_new (domain, DllImportAttributeClass.99);
      D.27591 = mono_string_new (domain, scope);
      D.27592 = &attr->dll;
      mono_gc_wbarrier_set_field (attr, D.27592, D.27591);
      D.27593 = mono_string_new (domain, import);
      D.27594 = &attr->entry_point;
      mono_gc_wbarrier_set_field (attr, D.27594, D.27593);
      D.27595 = flags & 1792;
      D.27596 = D.27595 >> 8;
      D.27597 = (int) D.27596;
      attr->call_conv = D.27597;
      D.27598 = flags & 6;
      D.27599 = D.27598 >> 1;
      D.27600 = D.27599 + 1;
      D.27601 = (int) D.27600;
      attr->charset = D.27601;
      D.27602 = attr->charset;
      if (D.27602 == 1) goto <D.27603>; else goto <D.27604>;
      <D.27603>:
      attr->charset = 2;
      <D.27604>:
      D.27605 = flags & 1;
      D.27606 = D.27605 != 0;
      D.27607 = (unsigned char) D.27606;
      attr->exact_spelling = D.27607;
      D.27608 = flags & 64;
      D.27609 = D.27608 != 0;
      D.27610 = (unsigned char) D.27609;
      attr->set_last_error = D.27610;
      D.27611 = flags & 48;
      D.27612 = D.27611 == 16;
      D.27613 = (unsigned char) D.27612;
      attr->best_fit_mapping = D.27613;
      D.27614 = flags & 12288;
      D.27615 = D.27614 == 4096;
      D.27616 = (unsigned char) D.27615;
      attr->throw_on_unmappable = D.27616;
      attr->preserve_sig = 0;
      D.27553 = attr;
      return D.27553;
    }
  finally
    {
      im_cols = {CLOBBER};
    }
}


ves_icall_MonoGenericMethod_get_ReflectedType (struct MonoReflectionGenericMethod * rmethod)
{
  struct MonoReflectionType * D.27619;
  struct MonoClass * D.27620;
  struct MonoType * D.27621;
  struct MonoVTable * D.27622;
  struct MonoDomain * D.27623;
  struct MonoMethod * method;

  method = rmethod->method.method;
  D.27620 = method->klass;
  D.27621 = &D.27620->byval_arg;
  D.27622 = MEM[(struct MonoObject *)rmethod].vtable;
  D.27623 = D.27622->domain;
  D.27619 = mono_type_get_object (D.27623, D.27621);
  return D.27619;
}


ves_icall_MonoField_SetValueInternal (struct MonoReflectionField * field, struct MonoObject * obj, struct MonoObject * value)
{
  struct MonoClass * D.27625;
  struct MonoImage * D.27626;
  struct MonoAssembly * D.27627;
  int D.27628;
  struct MonoException * D.27631;
  <unnamed type> D.27632;
  int D.27635;
  unsigned char D.27638;
  unsigned char D.27639;
  unsigned char D.27642;
  int D.27643;
  struct MonoGenericInst * D.27646;
  unsigned char D.27647;
  unsigned char D.27648;
  _Bool D.27649;
  long int D.27650;
  long int D.27651;
  struct MonoClass * D.27654;
  int D.27655;
  struct MonoDomain * D.27658;
  void * D.27659;
  struct MonoClass * D.27661;
  unsigned char D.27662;
  unsigned char D.27663;
  short unsigned int D.27668;
  int D.27669;
  int D.27670;
  struct MonoClass * D.27673;
  struct MonoVTable * D.27674;
  struct MonoDomain * D.27675;
  unsigned char D.27676;
  unsigned char D.27677;
  struct MonoError error;
  struct MonoClassField * cf;
  struct MonoType * type;
  gchar * v;

  try
    {
      cf = field->field;
      D.27625 = field->klass;
      D.27626 = D.27625->image;
      D.27627 = D.27626->assembly;
      D.27628 = D.27627->ref_only;
      if (D.27628 != 0) goto <D.27629>; else goto <D.27630>;
      <D.27629>:
      D.27631 = 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.27631);
      <D.27630>:
      D.27632 = mono_security_get_mode ();
      if (D.27632 == 1) goto <D.27633>; else goto <D.27634>;
      <D.27633>:
      mono_security_core_clr_ensure_reflection_access_field (cf);
      <D.27634>:
      type = mono_field_get_type_checked (cf, &error);
      D.27635 = mono_error_ok (&error);
      if (D.27635 == 0) goto <D.27636>; else goto <D.27637>;
      <D.27636>:
      mono_error_raise_exception (&error);
      <D.27637>:
      v = value;
      D.27638 = BIT_FIELD_REF <*type, 8, 56>;
      D.27639 = D.27638 & 64;
      if (D.27639 == 0) goto <D.27640>; else goto <D.27641>;
      <D.27640>:
      D.27642 = type->type;
      D.27643 = (int) D.27642;
      switch (D.27643) <default: <D.21126>, case 2: <D.21102>, case 3: <D.21105>, case 4: <D.21101>, case 5: <D.21100>, case 6: <D.21104>, case 7: <D.21103>, case 8: <D.21109>, case 9: <D.21108>, case 10: <D.21112>, case 11: <D.21111>, case 12: <D.21110>, case 13: <D.21113>, case 14: <D.21117>, case 15: <D.21115>, case 17: <D.21114>, case 18: <D.21119>, case 20: <D.21120>, case 21: <D.21122>, case 24: <D.21107>, case 25: <D.21106>, case 28: <D.21118>, case 29: <D.21121>>
      <D.21100>:
      <D.21101>:
      <D.21102>:
      <D.21103>:
      <D.21104>:
      <D.21105>:
      <D.21106>:
      <D.21107>:
      <D.21108>:
      <D.21109>:
      <D.21110>:
      <D.21111>:
      <D.21112>:
      <D.21113>:
      <D.21114>:
      <D.21115>:
      if (v != 0B) goto <D.27644>; else goto <D.27645>;
      <D.27644>:
      v = v + 8;
      <D.27645>:
      goto <D.21116>;
      <D.21117>:
      <D.21118>:
      <D.21119>:
      <D.21120>:
      <D.21121>:
      goto <D.21116>;
      <D.21122>:
      {
        struct MonoGenericClass * gclass;

        gclass = type->data.generic_class;
        D.27646 = gclass->context.class_inst;
        D.27647 = BIT_FIELD_REF <*D.27646, 8, 48>;
        D.27648 = D.27647 & 64;
        D.27649 = D.27648 != 0;
        D.27650 = (long int) D.27649;
        D.27651 = __builtin_expect (D.27650, 0);
        if (D.27651 != 0) goto <D.27652>; else goto <D.27653>;
        <D.27652>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "icall.c", 1825, "!gclass->context.class_inst->is_open");
        <D.27653>:
        D.27654 = mono_class_from_mono_type (type);
        D.27655 = mono_class_is_nullable (D.27654);
        if (D.27655 != 0) goto <D.27656>; else goto <D.27657>;
        <D.27656>:
        {
          struct MonoClass * nklass;
          struct MonoObject * nullable;

          nklass = mono_class_from_mono_type (type);
          D.27658 = mono_domain_get ();
          nullable = mono_object_new (D.27658, nklass);
          D.27659 = mono_object_unbox (nullable);
          mono_nullable_init (D.27659, value, nklass);
          v = mono_object_unbox (nullable);
        }
        goto <D.27660>;
        <D.27657>:
        D.27661 = gclass->container_class;
        D.27662 = BIT_FIELD_REF <*D.27661, 8, 160>;
        D.27663 = D.27662 & 8;
        if (D.27663 != 0) goto <D.27664>; else goto <D.27665>;
        <D.27664>:
        if (v != 0B) goto <D.27666>; else goto <D.27667>;
        <D.27666>:
        v = v + 8;
        <D.27667>:
        <D.27665>:
        <D.27660>:
        goto <D.21116>;
      }
      <D.21126>:
      D.27642 = type->type;
      D.27643 = (int) D.27642;
      monoeg_g_log (0B, 4, "type 0x%x not handled in ves_icall_FieldInfo_SetValueInternal", D.27643);
      <D.21127>:
      goto <D.21127>;
      return;
      <D.21116>:
      <D.27641>:
      D.27668 = type->attrs;
      D.27669 = (int) D.27668;
      D.27670 = D.27669 & 16;
      if (D.27670 != 0) goto <D.27671>; else goto <D.27672>;
      <D.27671>:
      {
        struct MonoVTable * vtable;

        D.27673 = cf->parent;
        D.27674 = MEM[(struct MonoObject *)field].vtable;
        D.27675 = D.27674->domain;
        vtable = mono_class_vtable_full (D.27675, D.27673, 1);
        D.27676 = BIT_FIELD_REF <*vtable, 8, 184>;
        D.27677 = D.27676 & 2;
        if (D.27677 == 0) goto <D.27678>; else goto <D.27679>;
        <D.27678>:
        mono_runtime_class_init (vtable);
        <D.27679>:
        mono_field_static_set_value (vtable, cf, v);
      }
      goto <D.27680>;
      <D.27672>:
      mono_field_set_value (obj, cf, v);
      <D.27680>:
    }
  finally
    {
      error = {CLOBBER};
    }
}


ves_icall_MonoField_ResolveType (struct MonoReflectionField * ref_field)
{
  int D.27682;
  struct MonoReflectionType * D.27685;
  struct MonoVTable * D.27686;
  struct MonoDomain * D.27687;
  struct MonoError error;
  struct MonoClassField * field;
  struct MonoType * type;

  try
    {
      field = ref_field->field;
      type = mono_field_get_type_checked (field, &error);
      D.27682 = mono_error_ok (&error);
      if (D.27682 == 0) goto <D.27683>; else goto <D.27684>;
      <D.27683>:
      mono_error_raise_exception (&error);
      <D.27684>:
      D.27686 = MEM[(struct MonoObject *)ref_field].vtable;
      D.27687 = D.27686->domain;
      D.27685 = mono_type_get_object (D.27687, type);
      return D.27685;
    }
  finally
    {
      error = {CLOBBER};
    }
}


ves_icall_MonoField_GetValueInternal (struct MonoReflectionField * field, struct MonoObject * obj)
{
  struct MonoVTable * D.27690;
  struct MonoImage * D.27691;
  struct MonoAssembly * D.27692;
  int D.27693;
  struct MonoException * D.27696;
  <unnamed type> D.27697;
  struct MonoObject * D.27700;
  struct MonoClass * fklass;
  struct MonoClassField * cf;
  struct MonoDomain * domain;

  fklass = field->klass;
  cf = field->field;
  D.27690 = MEM[(struct MonoObject *)field].vtable;
  domain = D.27690->domain;
  D.27691 = fklass->image;
  D.27692 = D.27691->assembly;
  D.27693 = D.27692->ref_only;
  if (D.27693 != 0) goto <D.27694>; else goto <D.27695>;
  <D.27694>:
  D.27696 = 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.27696);
  <D.27695>:
  D.27697 = mono_security_get_mode ();
  if (D.27697 == 1) goto <D.27698>; else goto <D.27699>;
  <D.27698>:
  mono_security_core_clr_ensure_reflection_access_field (cf);
  <D.27699>:
  D.27700 = mono_field_get_value_object (domain, cf, obj);
  return D.27700;
}


ves_icall_MonoField_GetRawConstantValue (struct MonoReflectionField * this)
{
  struct MonoVTable * D.27702;
  struct MonoClass * D.27703;
  int D.27704;
  short unsigned int D.27707;
  signed short D.27708;
  struct MonoException * D.27711;
  struct MonoImage * D.27712;
  unsigned char D.27713;
  unsigned char D.27714;
  struct MonoException * D.27719;
  <unnamed type> def_type.101;
  unsigned char D.27721;
  struct MonoObject * o.102;
  struct MonoObject * o.103;
  struct MonoObject * D.27724;
  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.27702 = MEM[(struct MonoObject *)this].vtable;
      domain = D.27702->domain;
      D.27703 = field->parent;
      mono_class_init (D.27703);
      t = mono_field_get_type_checked (field, &error);
      D.27704 = mono_error_ok (&error);
      if (D.27704 == 0) goto <D.27705>; else goto <D.27706>;
      <D.27705>:
      mono_error_raise_exception (&error);
      <D.27706>:
      D.27707 = t->attrs;
      D.27708 = (signed short) D.27707;
      if (D.27708 >= 0) goto <D.27709>; else goto <D.27710>;
      <D.27709>:
      D.27711 = mono_get_exception_invalid_operation (0B);
      mono_raise_exception (D.27711);
      <D.27710>:
      D.27703 = field->parent;
      D.27712 = D.27703->image;
      D.27713 = BIT_FIELD_REF <*D.27712, 8, 128>;
      D.27714 = D.27713 & 8;
      if (D.27714 != 0) goto <D.27715>; else goto <D.27716>;
      <D.27715>:
      monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "icall.c", 1890);
      <D.27716>:
      def_value = mono_class_get_field_default_value (field, &def_type);
      if (def_value == 0B) goto <D.27717>; else goto <D.27718>;
      <D.27717>:
      D.27719 = mono_get_exception_invalid_operation (0B);
      mono_raise_exception (D.27719);
      <D.27718>:
      def_type.101 = def_type;
      switch (def_type.101) <default: <D.21159>, case 2: <D.21143>, case 3: <D.21146>, case 4: <D.21142>, case 5: <D.21141>, case 6: <D.21145>, case 7: <D.21144>, case 8: <D.21150>, case 9: <D.21149>, case 10: <D.21153>, case 11: <D.21152>, case 12: <D.21151>, case 13: <D.21154>, case 14: <D.21157>, case 18: <D.21158>, case 24: <D.21148>, case 25: <D.21147>>
      <D.21141>:
      <D.21142>:
      <D.21143>:
      <D.21144>:
      <D.21145>:
      <D.21146>:
      <D.21147>:
      <D.21148>:
      <D.21149>:
      <D.21150>:
      <D.21151>:
      <D.21152>:
      <D.21153>:
      <D.21154>:
      {
        struct MonoType * t;

        t = monoeg_malloc0 (8);
        def_type.101 = def_type;
        D.27721 = (unsigned char) def_type.101;
        t->type = D.27721;
        klass = mono_class_from_mono_type (t);
        monoeg_g_free (t);
        o.102 = mono_object_new (domain, klass);
        o = o.102;
        o.103 = o;
        v = o.103 + 8;
        def_type.101 = def_type;
        mono_get_constant_value_from_blob (domain, def_type.101, def_value, v);
        goto <D.21156>;
      }
      <D.21157>:
      <D.21158>:
      def_type.101 = def_type;
      mono_get_constant_value_from_blob (domain, def_type.101, def_value, &o);
      goto <D.21156>;
      <D.21159>:
      monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "icall.c", 1930);
      <D.21156>:
      D.27724 = o;
      return D.27724;
    }
  finally
    {
      o = {CLOBBER};
      def_type = {CLOBBER};
      error = {CLOBBER};
    }
}


ves_icall_MonoField_GetParentType (struct MonoReflectionField * field, MonoBoolean declaring)
{
  struct MonoClass * iftmp.104;
  struct MonoClassField * D.27730;
  struct MonoReflectionType * D.27732;
  struct MonoType * D.27733;
  struct MonoVTable * D.27734;
  struct MonoDomain * D.27735;
  struct MonoClass * parent;

  if (declaring != 0) goto <D.27728>; else goto <D.27729>;
  <D.27728>:
  D.27730 = field->field;
  iftmp.104 = D.27730->parent;
  goto <D.27731>;
  <D.27729>:
  iftmp.104 = field->klass;
  <D.27731>:
  parent = iftmp.104;
  D.27733 = &parent->byval_arg;
  D.27734 = MEM[(struct MonoObject *)field].vtable;
  D.27735 = D.27734->domain;
  D.27732 = mono_type_get_object (D.27735, D.27733);
  return D.27732;
}


ves_icall_MonoField_GetFieldOffset (struct MonoReflectionField * field)
{
  struct MonoClassField * D.27737;
  unsigned char D.27738;
  unsigned char D.27739;
  gint32 D.27742;
  int D.27743;
  unsigned int D.27744;
  unsigned int D.27745;
  struct MonoClass * parent;

  D.27737 = field->field;
  parent = D.27737->parent;
  D.27738 = BIT_FIELD_REF <*parent, 8, 160>;
  D.27739 = D.27738 & 4;
  if (D.27739 == 0) goto <D.27740>; else goto <D.27741>;
  <D.27740>:
  mono_class_init (parent);
  <D.27741>:
  D.27737 = field->field;
  D.27743 = D.27737->offset;
  D.27744 = (unsigned int) D.27743;
  D.27745 = D.27744 + 4294967288;
  D.27742 = (gint32) D.27745;
  return D.27742;
}


ves_icall_get_event_info (struct MonoReflectionMonoEvent * event, struct MonoEventInfo * info)
{
  struct MonoVTable * D.27747;
  struct MonoClass * D.27748;
  struct MonoType * D.27749;
  struct MonoReflectionType * D.27750;
  struct MonoReflectionType * * D.27751;
  struct MonoEvent * D.27752;
  struct MonoClass * D.27753;
  struct MonoType * D.27754;
  struct MonoReflectionType * D.27755;
  struct MonoReflectionType * * D.27756;
  const char * D.27757;
  struct MonoString * D.27758;
  struct MonoString * * D.27759;
  unsigned int D.27760;
  struct MonoObject * iftmp.105;
  struct MonoMethod * D.27762;
  struct MonoReflectionMethod * * D.27766;
  struct MonoObject * iftmp.106;
  struct MonoMethod * D.27768;
  struct MonoReflectionMethod * * D.27772;
  struct MonoObject * iftmp.107;
  struct MonoMethod * D.27774;
  struct MonoReflectionMethod * * D.27778;
  struct MonoMethod * * D.27779;
  unsigned int n.108;
  unsigned int D.27783;
  struct MonoMethod * * D.27784;
  struct MonoMethod * D.27785;
  unsigned int n.109;
  struct MonoClass * D.27787;
  struct MonoArray * D.27788;
  struct MonoArray * * D.27789;
  unsigned int i.110;
  struct MonoArray * D.27791;
  unsigned int i.111;
  unsigned int D.27793;
  struct MonoMethod * * D.27794;
  struct MonoMethod * D.27795;
  struct MonoReflectionMethod * D.27796;
  struct MonoDomain * domain;

  D.27747 = MEM[(struct MonoObject *)event].vtable;
  domain = D.27747->domain;
  D.27748 = event->klass;
  D.27749 = &D.27748->byval_arg;
  D.27750 = mono_type_get_object (domain, D.27749);
  D.27751 = &info->reflected_type;
  mono_gc_wbarrier_generic_store (D.27751, D.27750);
  D.27752 = event->event;
  D.27753 = D.27752->parent;
  D.27754 = &D.27753->byval_arg;
  D.27755 = mono_type_get_object (domain, D.27754);
  D.27756 = &info->declaring_type;
  mono_gc_wbarrier_generic_store (D.27756, D.27755);
  D.27752 = event->event;
  D.27757 = D.27752->name;
  D.27758 = mono_string_new (domain, D.27757);
  D.27759 = &info->name;
  mono_gc_wbarrier_generic_store (D.27759, D.27758);
  D.27752 = event->event;
  D.27760 = D.27752->attrs;
  info->attrs = D.27760;
  D.27752 = event->event;
  D.27762 = D.27752->add;
  if (D.27762 != 0B) goto <D.27763>; else goto <D.27764>;
  <D.27763>:
  D.27752 = event->event;
  D.27762 = D.27752->add;
  iftmp.105 = mono_method_get_object (domain, D.27762, 0B);
  goto <D.27765>;
  <D.27764>:
  iftmp.105 = 0B;
  <D.27765>:
  D.27766 = &info->add_method;
  mono_gc_wbarrier_generic_store (D.27766, iftmp.105);
  D.27752 = event->event;
  D.27768 = D.27752->remove;
  if (D.27768 != 0B) goto <D.27769>; else goto <D.27770>;
  <D.27769>:
  D.27752 = event->event;
  D.27768 = D.27752->remove;
  iftmp.106 = mono_method_get_object (domain, D.27768, 0B);
  goto <D.27771>;
  <D.27770>:
  iftmp.106 = 0B;
  <D.27771>:
  D.27772 = &info->remove_method;
  mono_gc_wbarrier_generic_store (D.27772, iftmp.106);
  D.27752 = event->event;
  D.27774 = D.27752->raise;
  if (D.27774 != 0B) goto <D.27775>; else goto <D.27776>;
  <D.27775>:
  D.27752 = event->event;
  D.27774 = D.27752->raise;
  iftmp.107 = mono_method_get_object (domain, D.27774, 0B);
  goto <D.27777>;
  <D.27776>:
  iftmp.107 = 0B;
  <D.27777>:
  D.27778 = &info->raise_method;
  mono_gc_wbarrier_generic_store (D.27778, iftmp.107);
  D.27752 = event->event;
  D.27779 = D.27752->other;
  if (D.27779 != 0B) goto <D.27780>; else goto <D.27781>;
  <D.27780>:
  {
    int i;
    int n;

    n = 0;
    goto <D.21192>;
    <D.21191>:
    n = n + 1;
    <D.21192>:
    D.27752 = event->event;
    D.27779 = D.27752->other;
    n.108 = (unsigned int) n;
    D.27783 = n.108 * 4;
    D.27784 = D.27779 + D.27783;
    D.27785 = *D.27784;
    if (D.27785 != 0B) goto <D.21191>; else goto <D.21193>;
    <D.21193>:
    n.109 = (unsigned int) n;
    D.27787 = mono_defaults.method_info_class;
    D.27788 = mono_array_new (domain, D.27787, n.109);
    D.27789 = &info->other_methods;
    mono_gc_wbarrier_generic_store (D.27789, D.27788);
    i = 0;
    goto <D.21196>;
    <D.21195>:
    {
      void * * __p;

      i.110 = (unsigned int) i;
      D.27791 = info->other_methods;
      __p = mono_array_addr_with_size (D.27791, 4, i.110);
      D.27752 = event->event;
      D.27779 = D.27752->other;
      i.111 = (unsigned int) i;
      D.27793 = i.111 * 4;
      D.27794 = D.27779 + D.27793;
      D.27795 = *D.27794;
      D.27796 = mono_method_get_object (domain, D.27795, 0B);
      D.27791 = info->other_methods;
      mono_gc_wbarrier_set_arrayref (D.27791, __p, D.27796);
    }
    i = i + 1;
    <D.21196>:
    if (i < n) goto <D.21195>; else goto <D.21197>;
    <D.21197>:
  }
  <D.27781>:
}


ves_icall_InternalInvoke (struct MonoReflectionMethod * method, struct MonoObject * this, struct MonoArray * params, struct MonoException * * exc)
{
  <unnamed type> D.27797;
  short unsigned int D.27800;
  int D.27801;
  int D.27802;
  struct MonoClass * D.27805;
  struct MonoVTable * D.27806;
  struct MonoDomain * D.27807;
  struct MonoVTable * D.27808;
  struct MonoException * D.27811;
  struct MonoObject * D.27812;
  struct MonoObject * D.27815;
  struct MonoClass * D.27818;
  struct MonoImage * D.27819;
  struct MonoException * D.27820;
  unsigned char D.27821;
  unsigned char D.27822;
  int D.21496;
  int iftmp.112;
  int D.21495;
  const char[6] * D.27829;
  unsigned char D.27830;
  int D.27831;
  unsigned char D.27832;
  int D.27833;
  _Bool D.27834;
  _Bool D.27835;
  _Bool D.27836;
  const unsigned char * D.27839;
  unsigned char D.27840;
  int D.27841;
  const unsigned char * D.27842;
  unsigned char D.27843;
  int D.27844;
  _Bool D.27845;
  _Bool D.27846;
  const unsigned char * D.27849;
  unsigned char D.27850;
  int D.27851;
  const unsigned char * D.27852;
  unsigned char D.27853;
  int D.27854;
  _Bool D.27855;
  _Bool D.27856;
  const unsigned char * D.27859;
  unsigned char D.27860;
  int D.27861;
  const unsigned char * D.27862;
  unsigned char D.27863;
  int D.27864;
  const char * D.27866;
  unsigned char D.27869;
  unsigned char D.27870;
  struct MonoException * D.27873;
  struct MonoType * D.27874;
  unsigned char D.27875;
  unsigned char D.27876;
  struct MonoException * D.27879;
  int iftmp.113;
  unsigned int D.27883;
  short unsigned int D.27885;
  int D.27886;
  struct MonoException * D.27889;
  unsigned int D.27890;
  unsigned int D.27891;
  int D.21505;
  int iftmp.114;
  int D.21504;
  unsigned char D.27897;
  int D.27898;
  _Bool D.27899;
  _Bool D.27900;
  _Bool D.27901;
  const unsigned char * D.27904;
  unsigned char D.27905;
  int D.27906;
  _Bool D.27907;
  _Bool D.27908;
  const unsigned char * D.27911;
  unsigned char D.27912;
  int D.27913;
  _Bool D.27914;
  _Bool D.27915;
  const unsigned char * D.27918;
  unsigned char D.27919;
  int D.27920;
  struct MonoException * D.27926;
  struct MonoAssembly * D.27927;
  int D.27928;
  struct MonoException * D.27931;
  unsigned char D.27932;
  unsigned char D.27933;
  int D.27936;
  struct MonoException * D.27939;
  unsigned char D.27940;
  int D.21514;
  int iftmp.115;
  int D.21513;
  unsigned char D.27946;
  int D.27947;
  _Bool D.27948;
  _Bool D.27949;
  _Bool D.27950;
  const unsigned char * D.27953;
  unsigned char D.27954;
  int D.27955;
  _Bool D.27956;
  _Bool D.27957;
  const unsigned char * D.27960;
  unsigned char D.27961;
  int D.27962;
  _Bool D.27963;
  _Bool D.27964;
  const unsigned char * D.27967;
  unsigned char D.27968;
  int D.27969;
  unsigned int D.27973;
  unsigned int pcount.116;
  unsigned int D.27975;
  unsigned int i.117;
  unsigned int D.27977;
  uintptr_t * D.27978;
  unsigned int i.118;
  char * D.27980;
  void * D.27981;
  int32_t * D.27982;
  int D.27983;
  unsigned int D.27984;
  int D.27985;
  int D.27989;
  _Bool D.27990;
  long int D.27991;
  long int D.27992;
  unsigned int D.27995;
  unsigned int D.27996;
  struct MonoVTable * D.27997;
  struct MonoDomain * D.27998;
  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.27797 = mono_security_get_mode ();
  if (D.27797 == 1) goto <D.27798>; else goto <D.27799>;
  <D.27798>:
  mono_security_core_clr_ensure_reflection_access_method (m);
  <D.27799>:
  D.27800 = m->flags;
  D.27801 = (int) D.27800;
  D.27802 = D.27801 & 16;
  if (D.27802 == 0) goto <D.27803>; else goto <D.27804>;
  <D.27803>:
  D.27805 = m->klass;
  D.27806 = MEM[(struct MonoObject *)method].vtable;
  D.27807 = D.27806->domain;
  D.27808 = mono_class_vtable_full (D.27807, D.27805, 0);
  if (D.27808 == 0B) goto <D.27809>; else goto <D.27810>;
  <D.27809>:
  D.27805 = m->klass;
  D.27811 = mono_class_get_exception_for_failure (D.27805);
  mono_gc_wbarrier_generic_store (exc, D.27811);
  D.27812 = 0B;
  return D.27812;
  <D.27810>:
  if (this != 0B) goto <D.27813>; else goto <D.27814>;
  <D.27813>:
  D.27805 = m->klass;
  D.27815 = mono_object_isinst (this, D.27805);
  if (D.27815 == 0B) goto <D.27816>; else goto <D.27817>;
  <D.27816>:
  {
    char * this_name;
    char * target_name;
    char * msg;

    D.27818 = mono_object_get_class (this);
    this_name = mono_type_get_full_name (D.27818);
    D.27805 = m->klass;
    target_name = mono_type_get_full_name (D.27805);
    msg = monoeg_g_strdup_printf ("Object of type \'%s\' doesn\'t match target type \'%s\'", this_name, target_name);
    D.27819 = mono_defaults.corlib;
    D.27820 = mono_exception_from_name_msg (D.27819, "System.Reflection", "TargetException", msg);
    mono_gc_wbarrier_generic_store (exc, D.27820);
    monoeg_g_free (msg);
    monoeg_g_free (target_name);
    monoeg_g_free (this_name);
    D.27812 = 0B;
    return D.27812;
  }
  <D.27817>:
  m = mono_object_get_virtual_method (this, m);
  D.27805 = m->klass;
  D.27821 = BIT_FIELD_REF <*D.27805, 8, 160>;
  D.27822 = D.27821 & 8;
  if (D.27822 != 0) goto <D.27823>; else goto <D.27824>;
  <D.27823>:
  obj = mono_object_unbox (this);
  <D.27824>:
  goto <D.27825>;
  <D.27814>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = m->name;
      D.27829 = ".ctor";
      D.27830 = MEM[(const unsigned char *)D.27829];
      D.27831 = (int) D.27830;
      D.27832 = *__s2;
      D.27833 = (int) D.27832;
      __result = D.27831 - D.27833;
      {
        D.27834 = __s2_len != 0;
        D.27835 = __result == 0;
        D.27836 = D.27834 & D.27835;
        if (D.27836 != 0) goto <D.27837>; else goto <D.27838>;
        <D.27837>:
        D.27839 = &MEM[(void *)".ctor" + 1B];
        D.27840 = *D.27839;
        D.27841 = (int) D.27840;
        D.27842 = __s2 + 1;
        D.27843 = *D.27842;
        D.27844 = (int) D.27843;
        __result = D.27841 - D.27844;
        D.27845 = __s2_len > 1;
        D.27835 = __result == 0;
        D.27846 = D.27845 & D.27835;
        if (D.27846 != 0) goto <D.27847>; else goto <D.27848>;
        <D.27847>:
        D.27849 = &MEM[(void *)".ctor" + 2B];
        D.27850 = *D.27849;
        D.27851 = (int) D.27850;
        D.27852 = __s2 + 2;
        D.27853 = *D.27852;
        D.27854 = (int) D.27853;
        __result = D.27851 - D.27854;
        D.27855 = __s2_len > 2;
        D.27835 = __result == 0;
        D.27856 = D.27855 & D.27835;
        if (D.27856 != 0) goto <D.27857>; else goto <D.27858>;
        <D.27857>:
        D.27859 = &MEM[(void *)".ctor" + 3B];
        D.27860 = *D.27859;
        D.27861 = (int) D.27860;
        D.27862 = __s2 + 3;
        D.27863 = *D.27862;
        D.27864 = (int) D.27863;
        __result = D.27861 - D.27864;
        <D.27858>:
        <D.27848>:
        <D.27838>:
      }
      D.21495 = __result;
    }
    iftmp.112 = -D.21495;
    goto <D.27865>;
    <D.27828>:
    D.27866 = m->name;
    iftmp.112 = __builtin_strcmp (D.27866, ".ctor");
    <D.27865>:
    D.21496 = iftmp.112;
  }
  if (D.21496 != 0) goto <D.27867>; else goto <D.27868>;
  <D.27867>:
  D.27869 = BIT_FIELD_REF <*m, 8, 160>;
  D.27870 = D.27869 & 124;
  if (D.27870 == 0) goto <D.27871>; else goto <D.27872>;
  <D.27871>:
  D.27819 = mono_defaults.corlib;
  D.27873 = mono_exception_from_name_msg (D.27819, "System.Reflection", "TargetException", "Non-static method requires a target.");
  mono_gc_wbarrier_generic_store (exc, D.27873);
  D.27812 = 0B;
  return D.27812;
  <D.27872>:
  <D.27868>:
  <D.27825>:
  <D.27804>:
  D.27874 = sig->ret;
  D.27875 = BIT_FIELD_REF <*D.27874, 8, 56>;
  D.27876 = D.27875 & 64;
  if (D.27876 != 0) goto <D.27877>; else goto <D.27878>;
  <D.27877>:
  D.27819 = mono_defaults.corlib;
  D.27879 = mono_exception_from_name_msg (D.27819, "System", "NotSupportedException", "Cannot invoke method returning ByRef type via reflection");
  mono_gc_wbarrier_generic_store (exc, D.27879);
  D.27812 = 0B;
  return D.27812;
  <D.27878>:
  if (params != 0B) goto <D.27881>; else goto <D.27882>;
  <D.27881>:
  D.27883 = mono_array_length (params);
  iftmp.113 = (int) D.27883;
  goto <D.27884>;
  <D.27882>:
  iftmp.113 = 0;
  <D.27884>:
  pcount = iftmp.113;
  D.27885 = sig->param_count;
  D.27886 = (int) D.27885;
  if (D.27886 != pcount) goto <D.27887>; else goto <D.27888>;
  <D.27887>:
  D.27819 = mono_defaults.corlib;
  D.27889 = mono_exception_from_name (D.27819, "System.Reflection", "TargetParameterCountException");
  mono_gc_wbarrier_generic_store (exc, D.27889);
  D.27812 = 0B;
  return D.27812;
  <D.27888>:
  D.27805 = m->klass;
  D.27890 = D.27805->flags;
  D.27891 = D.27890 & 128;
  if (D.27891 != 0) goto <D.27892>; else goto <D.27893>;
  <D.27892>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = m->name;
      D.27829 = ".ctor";
      D.27830 = MEM[(const unsigned char *)D.27829];
      D.27831 = (int) D.27830;
      D.27897 = *__s2;
      D.27898 = (int) D.27897;
      __result = D.27831 - D.27898;
      {
        D.27899 = __s2_len != 0;
        D.27900 = __result == 0;
        D.27901 = D.27899 & D.27900;
        if (D.27901 != 0) goto <D.27902>; else goto <D.27903>;
        <D.27902>:
        D.27839 = &MEM[(void *)".ctor" + 1B];
        D.27840 = *D.27839;
        D.27841 = (int) D.27840;
        D.27904 = __s2 + 1;
        D.27905 = *D.27904;
        D.27906 = (int) D.27905;
        __result = D.27841 - D.27906;
        D.27907 = __s2_len > 1;
        D.27900 = __result == 0;
        D.27908 = D.27907 & D.27900;
        if (D.27908 != 0) goto <D.27909>; else goto <D.27910>;
        <D.27909>:
        D.27849 = &MEM[(void *)".ctor" + 2B];
        D.27850 = *D.27849;
        D.27851 = (int) D.27850;
        D.27911 = __s2 + 2;
        D.27912 = *D.27911;
        D.27913 = (int) D.27912;
        __result = D.27851 - D.27913;
        D.27914 = __s2_len > 2;
        D.27900 = __result == 0;
        D.27915 = D.27914 & D.27900;
        if (D.27915 != 0) goto <D.27916>; else goto <D.27917>;
        <D.27916>:
        D.27859 = &MEM[(void *)".ctor" + 3B];
        D.27860 = *D.27859;
        D.27861 = (int) D.27860;
        D.27918 = __s2 + 3;
        D.27919 = *D.27918;
        D.27920 = (int) D.27919;
        __result = D.27861 - D.27920;
        <D.27917>:
        <D.27910>:
        <D.27903>:
      }
      D.21504 = __result;
    }
    iftmp.114 = -D.21504;
    goto <D.27921>;
    <D.27896>:
    D.27866 = m->name;
    iftmp.114 = __builtin_strcmp (D.27866, ".ctor");
    <D.27921>:
    D.21505 = iftmp.114;
  }
  if (D.21505 == 0) goto <D.27922>; else goto <D.27923>;
  <D.27922>:
  if (this == 0B) goto <D.27924>; else goto <D.27925>;
  <D.27924>:
  D.27819 = mono_defaults.corlib;
  D.27926 = mono_exception_from_name_msg (D.27819, "System.Reflection", "TargetException", "Cannot invoke constructor of an abstract class.");
  mono_gc_wbarrier_generic_store (exc, D.27926);
  D.27812 = 0B;
  return D.27812;
  <D.27925>:
  <D.27923>:
  <D.27893>:
  D.27805 = m->klass;
  image = D.27805->image;
  D.27927 = image->assembly;
  D.27928 = D.27927->ref_only;
  if (D.27928 != 0) goto <D.27929>; else goto <D.27930>;
  <D.27929>:
  D.27931 = 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.27931);
  D.27812 = 0B;
  return D.27812;
  <D.27930>:
  D.27932 = BIT_FIELD_REF <*image, 8, 128>;
  D.27933 = D.27932 & 8;
  if (D.27933 != 0) goto <D.27934>; else goto <D.27935>;
  <D.27934>:
  D.27936 = MEM[(struct MonoDynamicImage *)image].run;
  if (D.27936 == 0) goto <D.27937>; else goto <D.27938>;
  <D.27937>:
  D.27939 = mono_get_exception_not_supported ("Cannot invoke a method in a dynamic assembly without run access.");
  mono_gc_wbarrier_generic_store (exc, D.27939);
  D.27812 = 0B;
  return D.27812;
  <D.27938>:
  <D.27935>:
  D.27805 = m->klass;
  D.27940 = D.27805->rank;
  if (D.27940 != 0) goto <D.27941>; else goto <D.27942>;
  <D.27941>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = m->name;
      D.27829 = ".ctor";
      D.27830 = MEM[(const unsigned char *)D.27829];
      D.27831 = (int) D.27830;
      D.27946 = *__s2;
      D.27947 = (int) D.27946;
      __result = D.27831 - D.27947;
      {
        D.27948 = __s2_len != 0;
        D.27949 = __result == 0;
        D.27950 = D.27948 & D.27949;
        if (D.27950 != 0) goto <D.27951>; else goto <D.27952>;
        <D.27951>:
        D.27839 = &MEM[(void *)".ctor" + 1B];
        D.27840 = *D.27839;
        D.27841 = (int) D.27840;
        D.27953 = __s2 + 1;
        D.27954 = *D.27953;
        D.27955 = (int) D.27954;
        __result = D.27841 - D.27955;
        D.27956 = __s2_len > 1;
        D.27949 = __result == 0;
        D.27957 = D.27956 & D.27949;
        if (D.27957 != 0) goto <D.27958>; else goto <D.27959>;
        <D.27958>:
        D.27849 = &MEM[(void *)".ctor" + 2B];
        D.27850 = *D.27849;
        D.27851 = (int) D.27850;
        D.27960 = __s2 + 2;
        D.27961 = *D.27960;
        D.27962 = (int) D.27961;
        __result = D.27851 - D.27962;
        D.27963 = __s2_len > 2;
        D.27949 = __result == 0;
        D.27964 = D.27963 & D.27949;
        if (D.27964 != 0) goto <D.27965>; else goto <D.27966>;
        <D.27965>:
        D.27859 = &MEM[(void *)".ctor" + 3B];
        D.27860 = *D.27859;
        D.27861 = (int) D.27860;
        D.27967 = __s2 + 3;
        D.27968 = *D.27967;
        D.27969 = (int) D.27968;
        __result = D.27861 - D.27969;
        <D.27966>:
        <D.27959>:
        <D.27952>:
      }
      D.21513 = __result;
    }
    iftmp.115 = -D.21513;
    goto <D.27970>;
    <D.27945>:
    D.27866 = m->name;
    iftmp.115 = __builtin_strcmp (D.27866, ".ctor");
    <D.27970>:
    D.21514 = iftmp.115;
  }
  if (D.21514 == 0) goto <D.27971>; else goto <D.27972>;
  <D.27971>:
  {
    int i;
    uintptr_t * lengths;
    intptr_t * lower_bounds;

    D.27973 = mono_array_length (params);
    pcount = (int) D.27973;
    pcount.116 = (unsigned int) pcount;
    D.27975 = pcount.116 * 4;
    lengths = __builtin_alloca (D.27975);
    i = 0;
    goto <D.21519>;
    <D.21518>:
    i.117 = (unsigned int) i;
    D.27977 = i.117 * 4;
    D.27978 = lengths + D.27977;
    i.118 = (unsigned int) i;
    D.27980 = mono_array_addr_with_size (params, 4, i.118);
    D.27981 = MEM[(void * *)D.27980];
    D.27982 = D.27981 + 8;
    D.27983 = *D.27982;
    D.27984 = (unsigned int) D.27983;
    *D.27978 = D.27984;
    i = i + 1;
    <D.21519>:
    if (i < pcount) goto <D.21518>; else goto <D.21520>;
    <D.21520>:
    D.27805 = m->klass;
    D.27940 = D.27805->rank;
    D.27985 = (int) D.27940;
    if (D.27985 == pcount) goto <D.27986>; else goto <D.27987>;
    <D.27986>:
    lower_bounds = 0B;
    goto <D.27988>;
    <D.27987>:
    D.27805 = m->klass;
    D.27940 = D.27805->rank;
    D.27985 = (int) D.27940;
    D.27989 = D.27985 * 2;
    D.27990 = D.27989 != pcount;
    D.27991 = (long int) D.27990;
    D.27992 = __builtin_expect (D.27991, 0);
    if (D.27992 != 0) goto <D.27993>; else goto <D.27994>;
    <D.27993>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "icall.c", 2835, "pcount == (m->klass->rank * 2)");
    <D.27994>:
    lower_bounds = lengths;
    D.27805 = m->klass;
    D.27940 = D.27805->rank;
    D.27995 = (unsigned int) D.27940;
    D.27996 = D.27995 * 4;
    lengths = lengths + D.27996;
    <D.27988>:
    D.27805 = m->klass;
    D.27997 = MEM[(struct MonoObject *)params].vtable;
    D.27998 = D.27997->domain;
    D.27812 = mono_array_new_full (D.27998, D.27805, lengths, lower_bounds);
    return D.27812;
  }
  <D.27972>:
  <D.27942>:
  D.27812 = mono_runtime_invoke_array (m, obj, params, 0B);
  return D.27812;
}


ves_icall_MonoMethod_GetGenericMethodDefinition (struct MonoReflectionMethod * method)
{
  struct MonoMethod * D.28000;
  unsigned char D.28001;
  unsigned char D.28002;
  struct MonoReflectionMethod * D.28005;
  unsigned char D.28006;
  unsigned char D.28009;
  unsigned char D.28010;
  struct MonoClass * D.28013;
  struct MonoImage * D.28014;
  unsigned char D.28015;
  unsigned char D.28016;
  struct MonoGHashTable * D.28019;
  struct MonoGenericInst * D.28022;
  struct MonoGenericContext * D.28025;
  struct MonoGenericContext * D.28028;
  struct MonoVTable * D.28029;
  struct MonoDomain * D.28030;
  struct MonoMethodInflated * imethod;
  struct MonoMethod * result;

  D.28000 = method->method;
  D.28001 = BIT_FIELD_REF <*D.28000, 8, 168>;
  D.28002 = D.28001 & 8;
  if (D.28002 != 0) goto <D.28003>; else goto <D.28004>;
  <D.28003>:
  D.28005 = method;
  return D.28005;
  <D.28004>:
  D.28000 = method->method;
  D.28001 = BIT_FIELD_REF <*D.28000, 8, 168>;
  D.28006 = D.28001 & 16;
  if (D.28006 == 0) goto <D.28007>; else goto <D.28008>;
  <D.28007>:
  D.28005 = 0B;
  return D.28005;
  <D.28008>:
  imethod = method->method;
  result = imethod->declaring;
  D.28009 = BIT_FIELD_REF <*result, 8, 168>;
  D.28010 = D.28009 & 8;
  if (D.28010 == 0) goto <D.28011>; else goto <D.28012>;
  <D.28011>:
  D.28005 = 0B;
  return D.28005;
  <D.28012>:
  D.28000 = method->method;
  D.28013 = D.28000->klass;
  D.28014 = D.28013->image;
  D.28015 = BIT_FIELD_REF <*D.28014, 8, 128>;
  D.28016 = D.28015 & 8;
  if (D.28016 != 0) goto <D.28017>; else goto <D.28018>;
  <D.28017>:
  {
    struct MonoDynamicImage * image;
    struct MonoReflectionMethod * res;

    D.28000 = method->method;
    D.28013 = D.28000->klass;
    image = D.28013->image;
    mono_image_lock (image);
    D.28019 = image->generic_def_objects;
    res = mono_g_hash_table_lookup (D.28019, imethod);
    mono_image_unlock (image);
    if (res != 0B) goto <D.28020>; else goto <D.28021>;
    <D.28020>:
    D.28005 = res;
    return D.28005;
    <D.28021>:
  }
  <D.28018>:
  D.28022 = imethod->context.class_inst;
  if (D.28022 != 0B) goto <D.28023>; else goto <D.28024>;
  <D.28023>:
  {
    struct MonoClass * klass;

    klass = MEM[(struct MonoMethod *)imethod].klass;
    D.28025 = mono_class_get_context (klass);
    if (D.28025 != 0B) goto <D.28026>; else goto <D.28027>;
    <D.28026>:
    D.28028 = mono_class_get_context (klass);
    result = mono_class_inflate_generic_method_full (result, klass, D.28028);
    <D.28027>:
  }
  <D.28024>:
  D.28029 = MEM[(struct MonoObject *)method].vtable;
  D.28030 = D.28029->domain;
  D.28005 = mono_method_get_object (D.28030, result, 0B);
  return D.28005;
}


ves_icall_System_Reflection_Module_ResolveTypeToken (struct MonoImage * image, guint32 token, struct MonoArray * type_args, struct MonoArray * method_args, MonoResolveTokenError * error)
{
  unsigned int D.28032;
  int token.119;
  unsigned int table.120;
  unsigned int D.28035;
  _Bool D.28036;
  _Bool D.28037;
  _Bool D.28038;
  struct MonoType * D.28041;
  unsigned char D.28042;
  unsigned char D.28043;
  struct MonoType * iftmp.121;
  struct MonoType * iftmp.122;
  <unnamed-unsigned:24> D.28059;
  int D.28060;
  struct MonoLoaderError * D.28061;
  struct MonoLoaderError * D.28064;
  struct MonoException * D.28065;
  struct MonoClass * klass;
  int table;
  int index;
  struct MonoGenericContext context;

  try
    {
      D.28032 = token >> 24;
      table = (int) D.28032;
      token.119 = (int) token;
      index = token.119 & 16777215;
      *error = 2;
      table.120 = (unsigned int) table;
      D.28035 = table.120 + 4294967295;
      D.28036 = D.28035 > 1;
      D.28037 = table != 27;
      D.28038 = D.28036 & D.28037;
      if (D.28038 != 0) goto <D.28039>; else goto <D.28040>;
      <D.28039>:
      *error = 1;
      D.28041 = 0B;
      return D.28041;
      <D.28040>:
      D.28042 = BIT_FIELD_REF <*image, 8, 128>;
      D.28043 = D.28042 & 8;
      if (D.28043 != 0) goto <D.28044>; else goto <D.28045>;
      <D.28044>:
      table.120 = (unsigned int) table;
      D.28035 = table.120 + 4294967295;
      if (D.28035 <= 1) goto <D.28046>; else goto <D.28047>;
      <D.28046>:
      klass = mono_lookup_dynamic_token_class (image, token, 0, 0B, 0B);
      if (klass != 0B) goto <D.28049>; else goto <D.28050>;
      <D.28049>:
      iftmp.121 = &klass->byval_arg;
      goto <D.28051>;
      <D.28050>:
      iftmp.121 = 0B;
      <D.28051>:
      D.28041 = iftmp.121;
      return D.28041;
      <D.28047>:
      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.28053>; else goto <D.28054>;
      <D.28053>:
      iftmp.122 = &klass->byval_arg;
      goto <D.28055>;
      <D.28054>:
      iftmp.122 = 0B;
      <D.28055>:
      D.28041 = iftmp.122;
      return D.28041;
      <D.28045>:
      if (index <= 0) goto <D.28056>; else goto <D.28058>;
      <D.28058>:
      D.28059 = image->tables[table].rows;
      D.28060 = (int) D.28059;
      if (D.28060 < index) goto <D.28056>; else goto <D.28057>;
      <D.28056>:
      *error = 0;
      D.28041 = 0B;
      return D.28041;
      <D.28057>:
      init_generic_context_from_args (&context, type_args, method_args);
      klass = mono_class_get_full (image, token, &context);
      D.28061 = mono_loader_get_last_error ();
      if (D.28061 != 0B) goto <D.28062>; else goto <D.28063>;
      <D.28062>:
      D.28064 = mono_loader_get_last_error ();
      D.28065 = mono_loader_error_prepare_exception (D.28064);
      mono_raise_exception (D.28065);
      <D.28063>:
      if (klass != 0B) goto <D.28066>; else goto <D.28067>;
      <D.28066>:
      D.28041 = &klass->byval_arg;
      return D.28041;
      <D.28067>:
      D.28041 = 0B;
      return D.28041;
    }
  finally
    {
      context = {CLOBBER};
    }
}


init_generic_context_from_args (struct MonoGenericContext * context, struct MonoArray * type_args, struct MonoArray * method_args)
{
  char * D.28072;
  unsigned int D.28073;
  int D.28074;
  struct MonoGenericInst * D.28075;
  char * D.28079;
  unsigned int D.28080;
  int D.28081;
  struct MonoGenericInst * D.28082;

  if (type_args != 0B) goto <D.28070>; else goto <D.28071>;
  <D.28070>:
  D.28072 = mono_array_addr_with_size (type_args, 4, 0);
  D.28073 = mono_array_length (type_args);
  D.28074 = (int) D.28073;
  D.28075 = mono_metadata_get_generic_inst (D.28074, D.28072);
  context->class_inst = D.28075;
  goto <D.28076>;
  <D.28071>:
  context->class_inst = 0B;
  <D.28076>:
  if (method_args != 0B) goto <D.28077>; else goto <D.28078>;
  <D.28077>:
  D.28079 = mono_array_addr_with_size (method_args, 4, 0);
  D.28080 = mono_array_length (method_args);
  D.28081 = (int) D.28080;
  D.28082 = mono_metadata_get_generic_inst (D.28081, D.28079);
  context->method_inst = D.28082;
  goto <D.28083>;
  <D.28078>:
  context->method_inst = 0B;
  <D.28083>:
}


ves_icall_System_Reflection_Module_ResolveStringToken (struct MonoImage * image, guint32 token, MonoResolveTokenError * error)
{
  int token.123;
  unsigned int D.28085;
  struct MonoString * D.28088;
  unsigned char D.28089;
  unsigned char D.28090;
  unsigned int index.124;
  unsigned int D.28097;
  unsigned int index.125;
  struct MonoDomain * D.28099;
  int index;

  token.123 = (int) token;
  index = token.123 & 16777215;
  *error = 2;
  D.28085 = token & 4278190080;
  if (D.28085 != 1879048192) goto <D.28086>; else goto <D.28087>;
  <D.28086>:
  *error = 1;
  D.28088 = 0B;
  return D.28088;
  <D.28087>:
  D.28089 = BIT_FIELD_REF <*image, 8, 128>;
  D.28090 = D.28089 & 8;
  if (D.28090 != 0) goto <D.28091>; else goto <D.28092>;
  <D.28091>:
  D.28088 = mono_lookup_dynamic_token_class (image, token, 0, 0B, 0B);
  return D.28088;
  <D.28092>:
  if (index <= 0) goto <D.28093>; else goto <D.28095>;
  <D.28095>:
  index.124 = (unsigned int) index;
  D.28097 = image->heap_us.size;
  if (index.124 >= D.28097) goto <D.28093>; else goto <D.28094>;
  <D.28093>:
  *error = 0;
  D.28088 = 0B;
  return D.28088;
  <D.28094>:
  index.125 = (unsigned int) index;
  D.28099 = mono_domain_get ();
  D.28088 = mono_ldstr (D.28099, image, index.125);
  return D.28088;
}


ves_icall_System_Reflection_Module_ResolveSignature (struct MonoImage * image, guint32 token, MonoResolveTokenError * error)
{
  unsigned int D.28101;
  int token.126;
  struct MonoArray * D.28105;
  unsigned char D.28106;
  unsigned char D.28107;
  struct MonoTableInfo * D.28113;
  <unnamed-unsigned:24> D.28114;
  int D.28115;
  int D.28116;
  const struct MonoTableInfo * D.28117;
  const char * ptr.127;
  const char * ptr.128;
  struct MonoClass * D.28120;
  struct MonoDomain * D.28121;
  char * D.28122;
  int table;
  int idx;
  struct MonoTableInfo * tables;
  guint32 sig;
  guint32 len;
  const char * ptr;
  struct MonoArray * res;

  try
    {
      D.28101 = token >> 24;
      table = (int) D.28101;
      token.126 = (int) token;
      idx = token.126 & 16777215;
      tables = &image->tables;
      *error = 0;
      if (table != 17) goto <D.28103>; else goto <D.28104>;
      <D.28103>:
      D.28105 = 0B;
      return D.28105;
      <D.28104>:
      D.28106 = BIT_FIELD_REF <*image, 8, 128>;
      D.28107 = D.28106 & 8;
      if (D.28107 != 0) goto <D.28108>; else goto <D.28109>;
      <D.28108>:
      D.28105 = 0B;
      return D.28105;
      <D.28109>:
      if (idx == 0) goto <D.28110>; else goto <D.28112>;
      <D.28112>:
      D.28113 = tables + 204;
      D.28114 = D.28113->rows;
      D.28115 = (int) D.28114;
      if (D.28115 < idx) goto <D.28110>; else goto <D.28111>;
      <D.28110>:
      D.28105 = 0B;
      return D.28105;
      <D.28111>:
      D.28116 = idx + -1;
      D.28117 = tables + 204;
      sig = mono_metadata_decode_row_col (D.28117, D.28116, 0);
      ptr.127 = mono_metadata_blob_heap (image, sig);
      ptr = ptr.127;
      ptr.128 = ptr;
      len = mono_metadata_decode_blob_size (ptr.128, &ptr);
      D.28120 = mono_defaults.byte_class;
      D.28121 = mono_domain_get ();
      res = mono_array_new (D.28121, D.28120, len);
      ptr.128 = ptr;
      D.28122 = mono_array_addr_with_size (res, 1, 0);
      memcpy (D.28122, ptr.128, len);
      D.28105 = res;
      return D.28105;
    }
  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.28125;
  int token.129;
  _Bool D.28127;
  _Bool D.28128;
  _Bool D.28129;
  struct MonoMethod * D.28134;
  unsigned char D.28135;
  unsigned char D.28136;
  int D.28143;
  <unnamed-unsigned:24> D.28149;
  int D.28150;
  int D.28153;
  struct MonoLoaderError * D.28156;
  struct MonoLoaderError * D.28159;
  struct MonoException * D.28160;
  int table;
  int index;
  struct MonoGenericContext context;
  struct MonoMethod * method;

  try
    {
      D.28125 = token >> 24;
      table = (int) D.28125;
      token.129 = (int) token;
      index = token.129 & 16777215;
      *error = 2;
      D.28127 = table != 6;
      D.28128 = table != 43;
      D.28129 = D.28127 & D.28128;
      if (D.28129 != 0) goto <D.28130>; else goto <D.28131>;
      <D.28130>:
      if (table != 10) goto <D.28132>; else goto <D.28133>;
      <D.28132>:
      *error = 1;
      D.28134 = 0B;
      return D.28134;
      <D.28133>:
      <D.28131>:
      D.28135 = BIT_FIELD_REF <*image, 8, 128>;
      D.28136 = D.28135 & 8;
      if (D.28136 != 0) goto <D.28137>; else goto <D.28138>;
      <D.28137>:
      if (table == 6) goto <D.28139>; else goto <D.28140>;
      <D.28139>:
      D.28134 = mono_lookup_dynamic_token_class (image, token, 0, 0B, 0B);
      return D.28134;
      <D.28140>:
      if (table == 10) goto <D.28141>; else goto <D.28142>;
      <D.28141>:
      D.28143 = mono_memberref_is_method (image, token);
      if (D.28143 == 0) goto <D.28144>; else goto <D.28145>;
      <D.28144>:
      *error = 1;
      D.28134 = 0B;
      return D.28134;
      <D.28145>:
      <D.28142>:
      init_generic_context_from_args (&context, type_args, method_args);
      D.28134 = mono_lookup_dynamic_token_class (image, token, 0, 0B, &context);
      return D.28134;
      <D.28138>:
      if (index <= 0) goto <D.28146>; else goto <D.28148>;
      <D.28148>:
      D.28149 = image->tables[table].rows;
      D.28150 = (int) D.28149;
      if (D.28150 < index) goto <D.28146>; else goto <D.28147>;
      <D.28146>:
      *error = 0;
      D.28134 = 0B;
      return D.28134;
      <D.28147>:
      if (table == 10) goto <D.28151>; else goto <D.28152>;
      <D.28151>:
      D.28153 = mono_memberref_is_method (image, token);
      if (D.28153 == 0) goto <D.28154>; else goto <D.28155>;
      <D.28154>:
      *error = 1;
      D.28134 = 0B;
      return D.28134;
      <D.28155>:
      <D.28152>:
      init_generic_context_from_args (&context, type_args, method_args);
      method = mono_get_method_full (image, token, 0B, &context);
      D.28156 = mono_loader_get_last_error ();
      if (D.28156 != 0B) goto <D.28157>; else goto <D.28158>;
      <D.28157>:
      D.28159 = mono_loader_get_last_error ();
      D.28160 = mono_loader_error_prepare_exception (D.28159);
      mono_raise_exception (D.28160);
      <D.28158>:
      D.28134 = method;
      return D.28134;
    }
  finally
    {
      context = {CLOBBER};
    }
}


mono_memberref_is_method (struct MonoImage * image, guint32 token)
{
  unsigned char D.28163;
  unsigned char D.28164;
  unsigned int D.28167;
  unsigned int D.28168;
  int D.28169;
  struct MonoTableInfo * D.28170;
  unsigned int D.28171;
  const char * sig.130;
  const char * sig.131;
  gboolean D.28174;
  char D.28175;
  _Bool D.28176;
  void * D.28177;
  struct MonoClass * D.28180;
  struct MonoClass * handle_class.132;
  _Bool D.28182;

  D.28163 = BIT_FIELD_REF <*image, 8, 128>;
  D.28164 = D.28163 & 8;
  if (D.28164 == 0) goto <D.28165>; else goto <D.28166>;
  <D.28165>:
  {
    guint32 cols[3];
    const char * sig;

    try
      {
        D.28167 = token & 16777215;
        D.28168 = D.28167 + 4294967295;
        D.28169 = (int) D.28168;
        D.28170 = &image->tables[10];
        mono_metadata_decode_row (D.28170, D.28169, &cols, 3);
        D.28171 = cols[2];
        sig.130 = mono_metadata_blob_heap (image, D.28171);
        sig = sig.130;
        sig.131 = sig;
        mono_metadata_decode_blob_size (sig.131, &sig);
        sig.131 = sig;
        D.28175 = *sig.131;
        D.28176 = D.28175 != 6;
        D.28174 = (gboolean) D.28176;
        return D.28174;
      }
    finally
      {
        cols = {CLOBBER};
        sig = {CLOBBER};
      }
  }
  <D.28166>:
  {
    struct MonoClass * handle_class;

    try
      {
        D.28177 = mono_lookup_dynamic_token_class (image, token, 0, &handle_class, 0B);
        if (D.28177 == 0B) goto <D.28178>; else goto <D.28179>;
        <D.28178>:
        D.28174 = 0;
        return D.28174;
        <D.28179>:
        D.28180 = mono_defaults.methodhandle_class;
        handle_class.132 = handle_class;
        D.28182 = D.28180 == handle_class.132;
        D.28174 = (gboolean) D.28182;
        return D.28174;
      }
    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.28186;
  struct MonoObject * D.28189;
  struct MonoDomain * D.28190;
  struct MonoClass * D.28193;
  struct MonoDomain * D.28194;
  struct MonoClass * D.28197;
  struct MonoDomain * D.28198;
  int D.28199;
  struct MonoClass * D.28204;
  struct MonoDomain * D.28205;
  struct MonoClass * D.28208;
  struct MonoDomain * D.28209;
  int table;

  D.28186 = token >> 24;
  table = (int) D.28186;
  *error = 2;
  switch (table) <default: <D.22653>, case 1: <D.22642>, case 2: <D.22641>, case 4: <D.22648>, case 6: <D.22645>, case 10: <D.22650>, case 27: <D.22643>, case 43: <D.22646>>
  <D.22641>:
  <D.22642>:
  <D.22643>:
  {
    struct MonoType * t;

    t = ves_icall_System_Reflection_Module_ResolveTypeToken (image, token, type_args, method_args, error);
    if (t != 0B) goto <D.28187>; else goto <D.28188>;
    <D.28187>:
    D.28190 = mono_domain_get ();
    D.28189 = mono_type_get_object (D.28190, t);
    return D.28189;
    <D.28188>:
    D.28189 = 0B;
    return D.28189;
  }
  <D.22645>:
  <D.22646>:
  {
    struct MonoMethod * m;

    m = ves_icall_System_Reflection_Module_ResolveMethodToken (image, token, type_args, method_args, error);
    if (m != 0B) goto <D.28191>; else goto <D.28192>;
    <D.28191>:
    D.28193 = m->klass;
    D.28194 = mono_domain_get ();
    D.28189 = mono_method_get_object (D.28194, m, D.28193);
    return D.28189;
    <D.28192>:
    D.28189 = 0B;
    return D.28189;
  }
  <D.22648>:
  {
    struct MonoClassField * f;

    f = ves_icall_System_Reflection_Module_ResolveFieldToken (image, token, type_args, method_args, error);
    if (f != 0B) goto <D.28195>; else goto <D.28196>;
    <D.28195>:
    D.28197 = f->parent;
    D.28198 = mono_domain_get ();
    D.28189 = mono_field_get_object (D.28198, D.28197, f);
    return D.28189;
    <D.28196>:
    D.28189 = 0B;
    return D.28189;
  }
  <D.22650>:
  D.28199 = mono_memberref_is_method (image, token);
  if (D.28199 != 0) goto <D.28200>; else goto <D.28201>;
  <D.28200>:
  {
    struct MonoMethod * m;

    m = ves_icall_System_Reflection_Module_ResolveMethodToken (image, token, type_args, method_args, error);
    if (m != 0B) goto <D.28202>; else goto <D.28203>;
    <D.28202>:
    D.28204 = m->klass;
    D.28205 = mono_domain_get ();
    D.28189 = mono_method_get_object (D.28205, m, D.28204);
    return D.28189;
    <D.28203>:
    D.28189 = 0B;
    return D.28189;
  }
  <D.28201>:
  {
    struct MonoClassField * f;

    f = ves_icall_System_Reflection_Module_ResolveFieldToken (image, token, type_args, method_args, error);
    if (f != 0B) goto <D.28206>; else goto <D.28207>;
    <D.28206>:
    D.28208 = f->parent;
    D.28209 = mono_domain_get ();
    D.28189 = mono_field_get_object (D.28209, D.28208, f);
    return D.28189;
    <D.28207>:
    D.28189 = 0B;
    return D.28189;
  }
  <D.22653>:
  *error = 1;
  D.28189 = 0B;
  return D.28189;
}


ves_icall_System_Reflection_Module_ResolveFieldToken (struct MonoImage * image, guint32 token, struct MonoArray * type_args, struct MonoArray * method_args, MonoResolveTokenError * error)
{
  unsigned int D.28211;
  int token.133;
  _Bool D.28213;
  _Bool D.28214;
  _Bool D.28215;
  struct MonoClassField * D.28218;
  unsigned char D.28219;
  unsigned char D.28220;
  int D.28225;
  <unnamed-unsigned:24> D.28231;
  int D.28232;
  int D.28235;
  struct MonoLoaderError * D.28238;
  struct MonoLoaderError * D.28241;
  struct MonoException * D.28242;
  struct MonoClass * klass;
  int table;
  int index;
  struct MonoGenericContext context;
  struct MonoClassField * field;

  try
    {
      D.28211 = token >> 24;
      table = (int) D.28211;
      token.133 = (int) token;
      index = token.133 & 16777215;
      *error = 2;
      D.28213 = table != 4;
      D.28214 = table != 10;
      D.28215 = D.28213 & D.28214;
      if (D.28215 != 0) goto <D.28216>; else goto <D.28217>;
      <D.28216>:
      *error = 1;
      D.28218 = 0B;
      return D.28218;
      <D.28217>:
      D.28219 = BIT_FIELD_REF <*image, 8, 128>;
      D.28220 = D.28219 & 8;
      if (D.28220 != 0) goto <D.28221>; else goto <D.28222>;
      <D.28221>:
      if (table == 4) goto <D.28223>; else goto <D.28224>;
      <D.28223>:
      D.28218 = mono_lookup_dynamic_token_class (image, token, 0, 0B, 0B);
      return D.28218;
      <D.28224>:
      D.28225 = mono_memberref_is_method (image, token);
      if (D.28225 != 0) goto <D.28226>; else goto <D.28227>;
      <D.28226>:
      *error = 1;
      D.28218 = 0B;
      return D.28218;
      <D.28227>:
      init_generic_context_from_args (&context, type_args, method_args);
      D.28218 = mono_lookup_dynamic_token_class (image, token, 0, 0B, &context);
      return D.28218;
      <D.28222>:
      if (index <= 0) goto <D.28228>; else goto <D.28230>;
      <D.28230>:
      D.28231 = image->tables[table].rows;
      D.28232 = (int) D.28231;
      if (D.28232 < index) goto <D.28228>; else goto <D.28229>;
      <D.28228>:
      *error = 0;
      D.28218 = 0B;
      return D.28218;
      <D.28229>:
      if (table == 10) goto <D.28233>; else goto <D.28234>;
      <D.28233>:
      D.28235 = mono_memberref_is_method (image, token);
      if (D.28235 != 0) goto <D.28236>; else goto <D.28237>;
      <D.28236>:
      *error = 1;
      D.28218 = 0B;
      return D.28218;
      <D.28237>:
      <D.28234>:
      init_generic_context_from_args (&context, type_args, method_args);
      field = mono_field_from_token (image, token, &klass, &context);
      D.28238 = mono_loader_get_last_error ();
      if (D.28238 != 0B) goto <D.28239>; else goto <D.28240>;
      <D.28239>:
      D.28241 = mono_loader_get_last_error ();
      D.28242 = mono_loader_error_prepare_exception (D.28241);
      mono_raise_exception (D.28242);
      <D.28240>:
      D.28218 = field;
      return D.28218;
    }
  finally
    {
      klass = {CLOBBER};
      context = {CLOBBER};
    }
}


ves_icall_System_Reflection_Module_InternalGetTypes (struct MonoReflectionModule * module)
{
  struct MonoImage * D.28245;
  struct MonoArray * D.28248;
  struct MonoClass * D.28249;
  struct MonoVTable * D.28250;
  struct MonoDomain * D.28251;
  unsigned int i.134;
  struct MonoArray * exceptions.135;
  char * D.28254;
  unsigned int D.28257;
  struct MonoArray * exceptions;
  int i;

  try
    {
      D.28245 = module->image;
      if (D.28245 == 0B) goto <D.28246>; else goto <D.28247>;
      <D.28246>:
      D.28249 = mono_defaults.monotype_class;
      D.28250 = MEM[(struct MonoObject *)module].vtable;
      D.28251 = D.28250->domain;
      D.28248 = mono_array_new (D.28251, D.28249, 0);
      return D.28248;
      <D.28247>:
      {
        struct MonoArray * res;

        D.28245 = module->image;
        D.28250 = MEM[(struct MonoObject *)module].vtable;
        D.28251 = D.28250->domain;
        res = mono_module_get_types (D.28251, D.28245, &exceptions, 0);
        i = 0;
        goto <D.22579>;
        <D.22578>:
        {
          struct MonoException * ex;

          i.134 = (unsigned int) i;
          exceptions.135 = exceptions;
          D.28254 = mono_array_addr_with_size (exceptions.135, 4, i.134);
          ex = MEM[(struct MonoException * *)D.28254];
          if (ex != 0B) goto <D.28255>; else goto <D.28256>;
          <D.28255>:
          mono_raise_exception (ex);
          <D.28256>:
        }
        i = i + 1;
        <D.22579>:
        i.134 = (unsigned int) i;
        exceptions.135 = exceptions;
        D.28257 = mono_array_length (exceptions.135);
        if (i.134 < D.28257) goto <D.22578>; else goto <D.22580>;
        <D.22580>:
        D.28248 = res;
        return D.28248;
      }
    }
  finally
    {
      exceptions = {CLOBBER};
    }
}


mono_module_get_types (struct MonoDomain * domain, struct MonoImage * image, struct MonoArray * * exceptions, MonoBoolean exportedOnly)
{
  unsigned int D.28262;
  <unnamed-unsigned:24> D.28265;
  int D.28266;
  unsigned int count.136;
  struct MonoClass * D.28269;
  struct MonoClass * D.28270;
  struct MonoArray * D.28271;
  int D.28275;
  int D.28276;
  unsigned int D.28277;
  struct MonoType * D.28280;
  struct MonoReflectionType * D.28281;
  _Bool D.28283;
  long int D.28284;
  long int D.28285;
  struct MonoArray * D.28288;
  struct MonoLoaderError * D.28289;
  struct MonoArray * D.28292;
  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.28260>; else goto <D.28261>;
  <D.28260>:
  count = 0;
  i = 1;
  goto <D.22477>;
  <D.22476>:
  attrs = mono_metadata_decode_row_col (tdef, i, 0);
  visibility = attrs & 7;
  D.28262 = visibility + 4294967295;
  if (D.28262 <= 1) goto <D.28263>; else goto <D.28264>;
  <D.28263>:
  count = count + 1;
  <D.28264>:
  i = i + 1;
  <D.22477>:
  D.28265 = tdef->rows;
  D.28266 = (int) D.28265;
  if (D.28266 > i) goto <D.22476>; else goto <D.22478>;
  <D.22478>:
  goto <D.28267>;
  <D.28261>:
  D.28265 = tdef->rows;
  D.28266 = (int) D.28265;
  count = D.28266 + -1;
  <D.28267>:
  count.136 = (unsigned int) count;
  D.28269 = mono_defaults.monotype_class;
  res = mono_array_new (domain, D.28269, count.136);
  count.136 = (unsigned int) count;
  D.28270 = mono_defaults.exception_class;
  D.28271 = mono_array_new (domain, D.28270, count.136);
  *exceptions = D.28271;
  count = 0;
  i = 1;
  goto <D.22484>;
  <D.22483>:
  attrs = mono_metadata_decode_row_col (tdef, i, 0);
  visibility = attrs & 7;
  if (exportedOnly == 0) goto <D.28272>; else goto <D.28274>;
  <D.28274>:
  D.28262 = visibility + 4294967295;
  if (D.28262 <= 1) goto <D.28272>; else goto <D.28273>;
  <D.28272>:
  D.28275 = i + 1;
  D.28276 = D.28275 | 33554432;
  D.28277 = (unsigned int) D.28276;
  klass = mono_class_get (image, D.28277);
  if (klass != 0B) goto <D.28278>; else goto <D.28279>;
  <D.28278>:
  {
    void * * __p;

    count.136 = (unsigned int) count;
    __p = mono_array_addr_with_size (res, 4, count.136);
    D.28280 = &klass->byval_arg;
    D.28281 = mono_type_get_object (domain, D.28280);
    mono_gc_wbarrier_set_arrayref (res, __p, D.28281);
  }
  goto <D.28282>;
  <D.28279>:
  {
    struct MonoLoaderError * error;
    struct MonoException * ex;

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

      count.136 = (unsigned int) count;
      D.28288 = *exceptions;
      __p = mono_array_addr_with_size (D.28288, 4, count.136);
      D.28288 = *exceptions;
      mono_gc_wbarrier_set_arrayref (D.28288, __p, ex);
    }
  }
  <D.28282>:
  D.28289 = mono_loader_get_last_error ();
  if (D.28289 != 0B) goto <D.28290>; else goto <D.28291>;
  <D.28290>:
  mono_loader_clear_error ();
  <D.28291>:
  count = count + 1;
  <D.28273>:
  i = i + 1;
  <D.22484>:
  D.28265 = tdef->rows;
  D.28266 = (int) D.28265;
  if (D.28266 > i) goto <D.22483>; else goto <D.22485>;
  <D.22485>:
  D.28292 = res;
  return D.28292;
}


ves_icall_System_Reflection_Module_GetPEKind (struct MonoImage * image, gint32 * pe_kind, gint32 * machine)
{
  unsigned char D.28294;
  unsigned char D.28295;
  unsigned int D.28298;
  int D.28299;
  unsigned int D.28300;
  int D.28301;
  void * D.28303;
  unsigned int D.28304;
  int D.28305;
  int D.28306;
  short unsigned int D.28307;
  int D.28308;

  D.28294 = BIT_FIELD_REF <*image, 8, 128>;
  D.28295 = D.28294 & 8;
  if (D.28295 != 0) goto <D.28296>; else goto <D.28297>;
  <D.28296>:
  {
    struct MonoDynamicImage * dyn;

    dyn = image;
    D.28298 = dyn->pe_kind;
    D.28299 = (int) D.28298;
    *pe_kind = D.28299;
    D.28300 = dyn->machine;
    D.28301 = (int) D.28300;
    *machine = D.28301;
  }
  goto <D.28302>;
  <D.28297>:
  D.28303 = image->image_info;
  D.28304 = MEM[(struct MonoCLIImageInfo *)D.28303].cli_cli_header.ch_flags;
  D.28305 = (int) D.28304;
  D.28306 = D.28305 & 3;
  *pe_kind = D.28306;
  D.28303 = image->image_info;
  D.28307 = MEM[(struct MonoCLIImageInfo *)D.28303].cli_header.coff.coff_machine;
  D.28308 = (int) D.28307;
  *machine = D.28308;
  <D.28302>:
}


ves_icall_System_Reflection_Module_GetMDStreamVersion (struct MonoImage * image)
{
  gint32 D.28309;
  short int D.28310;
  int D.28311;
  int D.28312;
  short int D.28313;
  int D.28314;

  D.28310 = image->md_version_major;
  D.28311 = (int) D.28310;
  D.28312 = D.28311 << 16;
  D.28313 = image->md_version_minor;
  D.28314 = (int) D.28313;
  D.28309 = D.28312 | D.28314;
  return D.28309;
}


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

  D.28316 = 4294967295B;
  return D.28316;
}


ves_icall_System_Reflection_Module_GetGuidInternal (struct MonoReflectionModule * module)
{
  struct MonoVTable * D.28318;
  struct MonoImage * D.28319;
  _Bool D.28320;
  long int D.28321;
  long int D.28322;
  struct MonoString * D.28325;
  char * D.28326;
  struct MonoDomain * domain;

  D.28318 = MEM[(struct MonoObject *)module].vtable;
  domain = D.28318->domain;
  D.28319 = module->image;
  D.28320 = D.28319 == 0B;
  D.28321 = (long int) D.28320;
  D.28322 = __builtin_expect (D.28321, 0);
  if (D.28322 != 0) goto <D.28323>; else goto <D.28324>;
  <D.28323>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "icall.c", 5323, "module->image");
  <D.28324>:
  D.28319 = module->image;
  D.28326 = D.28319->guid;
  D.28325 = mono_string_new (domain, D.28326);
  return D.28325;
}


ves_icall_System_Reflection_Module_GetGlobalType (struct MonoReflectionModule * module)
{
  struct MonoVTable * D.28328;
  struct MonoImage * D.28329;
  _Bool D.28330;
  long int D.28331;
  long int D.28332;
  unsigned char D.28335;
  unsigned char D.28336;
  int D.28339;
  struct MonoReflectionType * D.28342;
  struct MonoType * D.28343;
  struct MonoDomain * domain;
  struct MonoClass * klass;

  D.28328 = MEM[(struct MonoObject *)module].vtable;
  domain = D.28328->domain;
  D.28329 = module->image;
  D.28330 = D.28329 == 0B;
  D.28331 = (long int) D.28330;
  D.28332 = __builtin_expect (D.28331, 0);
  if (D.28332 != 0) goto <D.28333>; else goto <D.28334>;
  <D.28333>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "icall.c", 5299, "module->image");
  <D.28334>:
  D.28329 = module->image;
  D.28335 = BIT_FIELD_REF <*D.28329, 8, 128>;
  D.28336 = D.28335 & 8;
  if (D.28336 != 0) goto <D.28337>; else goto <D.28338>;
  <D.28337>:
  D.28329 = module->image;
  D.28339 = MEM[(struct MonoDynamicImage *)D.28329].initial_image;
  if (D.28339 != 0) goto <D.28340>; else goto <D.28341>;
  <D.28340>:
  D.28342 = 0B;
  return D.28342;
  <D.28341>:
  <D.28338>:
  D.28329 = module->image;
  klass = mono_class_get (D.28329, 33554433);
  D.28343 = &klass->byval_arg;
  D.28342 = mono_type_get_object (domain, D.28343);
  return D.28342;
}


ves_icall_System_Reflection_Module_Close (struct MonoReflectionModule * module)
{

}


ves_icall_System_Reflection_MethodBase_GetMethodFromHandleInternalType (struct MonoMethod * method, struct MonoType * type)
{
  struct MonoClass * D.28347;
  struct MonoClass * D.28348;
  struct MonoClass * D.28349;
  struct MonoReflectionMethod * D.28352;
  struct MonoDomain * D.28358;
  struct MonoClass * klass;

  if (type != 0B) goto <D.28345>; else goto <D.28346>;
  <D.28345>:
  klass = mono_class_from_mono_type (type);
  D.28347 = method->klass;
  D.28348 = mono_class_get_generic_type_definition (D.28347);
  D.28349 = mono_class_get_generic_type_definition (klass);
  if (D.28348 != D.28349) goto <D.28350>; else goto <D.28351>;
  <D.28350>:
  D.28352 = 0B;
  return D.28352;
  <D.28351>:
  D.28347 = method->klass;
  if (D.28347 != klass) goto <D.28353>; else goto <D.28354>;
  <D.28353>:
  method = mono_method_get_equivalent_method (method, klass);
  if (method == 0B) goto <D.28355>; else goto <D.28356>;
  <D.28355>:
  D.28352 = 0B;
  return D.28352;
  <D.28356>:
  <D.28354>:
  goto <D.28357>;
  <D.28346>:
  klass = method->klass;
  <D.28357>:
  D.28358 = mono_domain_get ();
  D.28352 = mono_method_get_object (D.28358, method, klass);
  return D.28352;
}


mono_method_get_equivalent_method (struct MonoMethod * method, struct MonoClass * klass)
{
  unsigned char D.28360;
  unsigned char D.28361;
  struct MonoGenericInst * D.28364;
  struct MonoGenericInst * D.28367;
  struct MonoGenericInst * D.28368;
  struct MonoGenericClass * D.28369;
  struct MonoGenericInst * D.28372;
  struct MonoGenericContainer * D.28374;
  struct MonoGenericInst * D.28377;
  struct MonoMethod * D.28378;
  struct MonoMethod * D.28379;
  struct MonoClass * D.28380;
  unsigned char D.28381;
  struct MonoMethod * * D.28384;
  unsigned int i.137;
  unsigned int D.28386;
  struct MonoMethod * * D.28387;
  struct MonoMethod * D.28388;
  unsigned int i.138;
  unsigned int D.28392;
  unsigned char D.28393;
  int iftmp.139;
  unsigned int offset.140;
  unsigned int D.28402;
  _Bool D.28403;
  long int D.28404;
  long int D.28405;
  struct MonoMethod * * D.28408;
  unsigned int offset.141;
  unsigned int D.28410;
  struct MonoMethod * * D.28411;
  int offset;
  int i;

  offset = -1;
  D.28360 = BIT_FIELD_REF <*method, 8, 168>;
  D.28361 = D.28360 & 16;
  if (D.28361 != 0) goto <D.28362>; else goto <D.28363>;
  <D.28362>:
  D.28364 = MEM[(struct MonoMethodInflated *)method].context.method_inst;
  if (D.28364 != 0B) goto <D.28365>; else goto <D.28366>;
  <D.28365>:
  {
    struct MonoMethodInflated * inflated;
    struct MonoGenericContext ctx;

    try
      {
        inflated = method;
        D.28367 = inflated->context.method_inst;
        ctx.method_inst = D.28367;
        D.28368 = inflated->context.class_inst;
        ctx.class_inst = D.28368;
        D.28369 = klass->generic_class;
        if (D.28369 != 0B) goto <D.28370>; else goto <D.28371>;
        <D.28370>:
        D.28369 = klass->generic_class;
        D.28372 = D.28369->context.class_inst;
        ctx.class_inst = D.28372;
        goto <D.28373>;
        <D.28371>:
        D.28374 = klass->generic_container;
        if (D.28374 != 0B) goto <D.28375>; else goto <D.28376>;
        <D.28375>:
        D.28374 = klass->generic_container;
        D.28377 = D.28374->context.class_inst;
        ctx.class_inst = D.28377;
        <D.28376>:
        <D.28373>:
        D.28379 = inflated->declaring;
        D.28378 = mono_class_inflate_generic_method_full (D.28379, klass, &ctx);
        return D.28378;
      }
    finally
      {
        ctx = {CLOBBER};
      }
  }
  <D.28366>:
  <D.28363>:
  D.28380 = method->klass;
  mono_class_setup_methods (D.28380);
  D.28380 = method->klass;
  D.28381 = D.28380->exception_type;
  if (D.28381 != 0) goto <D.28382>; else goto <D.28383>;
  <D.28382>:
  D.28378 = 0B;
  return D.28378;
  <D.28383>:
  i = 0;
  goto <D.22366>;
  <D.22365>:
  D.28380 = method->klass;
  D.28384 = D.28380->methods;
  i.137 = (unsigned int) i;
  D.28386 = i.137 * 4;
  D.28387 = D.28384 + D.28386;
  D.28388 = *D.28387;
  if (D.28388 == method) goto <D.28389>; else goto <D.28390>;
  <D.28389>:
  offset = i;
  goto <D.22364>;
  <D.28390>:
  i = i + 1;
  <D.22366>:
  i.138 = (unsigned int) i;
  D.28380 = method->klass;
  D.28392 = D.28380->method.count;
  if (i.138 < D.28392) goto <D.22365>; else goto <D.22364>;
  <D.22364>:
  mono_class_setup_methods (klass);
  D.28393 = klass->exception_type;
  if (D.28393 != 0) goto <D.28394>; else goto <D.28395>;
  <D.28394>:
  D.28378 = 0B;
  return D.28378;
  <D.28395>:
  if (offset < 0) goto <D.28397>; else goto <D.28400>;
  <D.28400>:
  offset.140 = (unsigned int) offset;
  D.28402 = klass->method.count;
  if (offset.140 >= D.28402) goto <D.28397>; else goto <D.28398>;
  <D.28397>:
  iftmp.139 = 1;
  goto <D.28399>;
  <D.28398>:
  iftmp.139 = 0;
  <D.28399>:
  D.28403 = iftmp.139 != 0;
  D.28404 = (long int) D.28403;
  D.28405 = __builtin_expect (D.28404, 0);
  if (D.28405 != 0) goto <D.28406>; else goto <D.28407>;
  <D.28406>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "icall.c", 4779, "offset >= 0 && offset < klass->method.count");
  <D.28407>:
  D.28408 = klass->methods;
  offset.141 = (unsigned int) offset;
  D.28410 = offset.141 * 4;
  D.28411 = D.28408 + D.28410;
  D.28378 = *D.28411;
  return D.28378;
}


ves_icall_System_Reflection_MethodBase_GetMethodFromHandleInternal (struct MonoMethod * method)
{
  struct MonoReflectionMethod * D.28414;
  struct MonoDomain * D.28415;

  D.28415 = mono_domain_get ();
  D.28414 = mono_method_get_object (D.28415, method, 0B);
  return D.28414;
}


ves_icall_System_Reflection_MethodBase_GetMethodBodyInternal (struct MonoMethod * method)
{
  struct MonoReflectionMethodBody * D.28417;
  struct MonoDomain * D.28418;

  D.28418 = mono_domain_get ();
  D.28417 = mono_method_body_get_object (D.28418, method);
  return D.28417;
}


ves_icall_GetCurrentMethod ()
{
  unsigned char D.28420;
  unsigned char D.28421;
  struct MonoReflectionMethod * D.28422;
  struct MonoDomain * D.28423;
  struct MonoMethod * m;

  m = mono_method_get_last_managed ();
  goto <D.22354>;
  <D.22353>:
  m = MEM[(struct MonoMethodInflated *)m].declaring;
  <D.22354>:
  D.28420 = BIT_FIELD_REF <*m, 8, 168>;
  D.28421 = D.28420 & 16;
  if (D.28421 != 0) goto <D.22353>; else goto <D.22355>;
  <D.22355>:
  D.28423 = mono_domain_get ();
  D.28422 = mono_method_get_object (D.28423, m, 0B);
  return D.28422;
}


ves_icall_System_Reflection_FieldInfo_internal_from_handle_type (struct MonoClassField * handle, struct MonoType * type)
{
  _Bool D.28425;
  long int D.28426;
  long int D.28427;
  struct MonoClass * D.28433;
  struct MonoReflectionField * D.28438;
  struct MonoDomain * D.28439;
  gboolean found;
  struct MonoClass * klass;
  struct MonoClass * k;

  found = 0;
  D.28425 = handle == 0B;
  D.28426 = (long int) D.28425;
  D.28427 = __builtin_expect (D.28426, 0);
  if (D.28427 != 0) goto <D.28428>; else goto <D.28429>;
  <D.28428>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "icall.c", 1637, "handle");
  <D.28429>:
  if (type == 0B) goto <D.28430>; else goto <D.28431>;
  <D.28430>:
  klass = handle->parent;
  goto <D.28432>;
  <D.28431>:
  klass = mono_class_from_mono_type (type);
  k = klass;
  goto <D.21043>;
  <D.21042>:
  D.28433 = handle->parent;
  if (D.28433 == k) goto <D.28434>; else goto <D.28435>;
  <D.28434>:
  found = 1;
  goto <D.21041>;
  <D.28435>:
  k = k->parent;
  <D.21043>:
  if (k != 0B) goto <D.21042>; else goto <D.21041>;
  <D.21041>:
  if (found == 0) goto <D.28436>; else goto <D.28437>;
  <D.28436>:
  D.28438 = 0B;
  return D.28438;
  <D.28437>:
  <D.28432>:
  D.28439 = mono_domain_get ();
  D.28438 = mono_field_get_object (D.28439, klass, handle);
  return D.28438;
}


ves_icall_System_Reflection_FieldInfo_get_marshal_info (struct MonoReflectionField * field)
{
  struct MonoClassField * D.28441;
  struct MonoGenericContainer * D.28444;
  struct MonoGenericClass * D.28446;
  struct MonoGenericInst * D.28448;
  unsigned char D.28449;
  unsigned char D.28450;
  struct MonoReflectionMarshalAsAttribute * D.28451;
  struct MonoClassField * D.28452;
  struct MonoMarshalSpec * D.28455;
  struct MonoVTable * D.28458;
  struct MonoDomain * D.28459;
  unsigned int i.142;
  unsigned int D.28461;
  struct MonoClass * klass;
  struct MonoMarshalType * info;
  int i;

  D.28441 = field->field;
  klass = D.28441->parent;
  D.28444 = klass->generic_container;
  if (D.28444 != 0B) goto <D.28442>; else goto <D.28445>;
  <D.28445>:
  D.28446 = klass->generic_class;
  if (D.28446 != 0B) goto <D.28447>; else goto <D.28443>;
  <D.28447>:
  D.28446 = klass->generic_class;
  D.28448 = D.28446->context.class_inst;
  D.28449 = BIT_FIELD_REF <*D.28448, 8, 48>;
  D.28450 = D.28449 & 64;
  if (D.28450 != 0) goto <D.28442>; else goto <D.28443>;
  <D.28442>:
  D.28451 = 0B;
  return D.28451;
  <D.28443>:
  info = mono_marshal_load_type_info (klass);
  i = 0;
  goto <D.21032>;
  <D.21031>:
  D.28452 = info->fields[i].field;
  D.28441 = field->field;
  if (D.28452 == D.28441) goto <D.28453>; else goto <D.28454>;
  <D.28453>:
  D.28455 = info->fields[i].mspec;
  if (D.28455 == 0B) goto <D.28456>; else goto <D.28457>;
  <D.28456>:
  D.28451 = 0B;
  return D.28451;
  <D.28457>:
  D.28455 = info->fields[i].mspec;
  D.28458 = field->object.vtable;
  D.28459 = D.28458->domain;
  D.28451 = mono_reflection_marshal_as_attribute_from_marshal_spec (D.28459, klass, D.28455);
  return D.28451;
  <D.28454>:
  i = i + 1;
  <D.21032>:
  i.142 = (unsigned int) i;
  D.28461 = info->num_fields;
  if (i.142 < D.28461) goto <D.21031>; else goto <D.21033>;
  <D.21033>:
  D.28451 = 0B;
  return D.28451;
}


ves_icall_System_Reflection_FieldInfo_GetTypeModifiers (struct MonoReflectionField * field, MonoBoolean optional)
{
  struct MonoClassField * D.28463;
  int D.28464;
  struct MonoArray * D.28467;
  int D.28468;
  struct MonoClass * D.28469;
  struct MonoImage * D.28470;
  struct MonoError error;
  struct MonoType * type;

  try
    {
      D.28463 = field->field;
      type = mono_field_get_type_checked (D.28463, &error);
      D.28464 = mono_error_ok (&error);
      if (D.28464 == 0) goto <D.28465>; else goto <D.28466>;
      <D.28465>:
      mono_error_raise_exception (&error);
      <D.28466>:
      D.28468 = (int) optional;
      D.28463 = field->field;
      D.28469 = D.28463->parent;
      D.28470 = D.28469->image;
      D.28467 = type_array_from_modifiers (D.28470, type, D.28468);
      return D.28467;
    }
  finally
    {
      error = {CLOBBER};
    }
}


ves_icall_TypeBuilder_get_IsGenericParameter (struct MonoReflectionTypeBuilder * tb)
{
  MonoBoolean D.28473;
  struct MonoType * D.28474;

  D.28474 = tb->type.type;
  D.28473 = is_generic_parameter (D.28474);
  return D.28473;
}


ves_icall_ModuleBuilder_getToken (struct MonoReflectionModuleBuilder * mb, struct MonoObject * obj, gboolean create_open_instance)
{
  _Bool D.28476;
  long int D.28477;
  long int D.28478;
  gint32 D.28483;
  struct MonoDynamicImage * D.28484;
  unsigned int D.28485;

  D.28476 = obj == 0B;
  D.28477 = (long int) D.28476;
  D.28478 = __builtin_expect (D.28477, 0);
  if (D.28478 != 0) goto <D.28479>; else goto <D.28480>;
  <D.28479>:
  {
    struct MonoException * ex;

    if (obj != 0B) goto <D.28481>; else goto <D.28482>;
    <D.28481>:
    <D.28482>:
    ex = mono_get_exception_argument_null ("obj");
    mono_raise_exception (ex);
  }
  <D.28480>:
  D.28484 = mb->dynamic_image;
  D.28485 = mono_image_create_token (D.28484, obj, create_open_instance, 1);
  D.28483 = (gint32) D.28485;
  return D.28483;
}


ves_icall_ModuleBuilder_getMethodToken (struct MonoReflectionModuleBuilder * mb, struct MonoReflectionMethod * method, struct MonoArray * opt_param_types)
{
  _Bool D.28487;
  long int D.28488;
  long int D.28489;
  gint32 D.28494;
  struct MonoDynamicImage * D.28495;
  unsigned int D.28496;

  D.28487 = method == 0B;
  D.28488 = (long int) D.28487;
  D.28489 = __builtin_expect (D.28488, 0);
  if (D.28489 != 0) goto <D.28490>; else goto <D.28491>;
  <D.28490>:
  {
    struct MonoException * ex;

    if (method != 0B) goto <D.28492>; else goto <D.28493>;
    <D.28492>:
    <D.28493>:
    ex = mono_get_exception_argument_null ("method");
    mono_raise_exception (ex);
  }
  <D.28491>:
  D.28495 = mb->dynamic_image;
  D.28496 = mono_image_create_method_token (D.28495, method, opt_param_types);
  D.28494 = (gint32) D.28496;
  return D.28494;
}


ves_icall_ModuleBuilder_create_modified_type (struct MonoReflectionTypeBuilder * tb, struct MonoString * smodifiers)
{
  struct MonoType * D.28498;
  char D.28499;
  int D.28500;
  struct MonoReflectionType * D.28503;
  struct MonoType * D.28504;
  struct MonoVTable * D.28505;
  struct MonoDomain * D.28506;
  struct MonoType * D.28507;
  unsigned int rank.143;
  struct MonoClass * klass;
  int isbyref;
  int rank;
  char * str;
  char * p;

  isbyref = 0;
  str = mono_string_to_utf8 (smodifiers);
  D.28498 = tb->type.type;
  klass = mono_class_from_mono_type (D.28498);
  p = str;
  goto <D.22684>;
  <D.22683>:
  D.28499 = *p;
  D.28500 = (int) D.28499;
  switch (D.28500) <default: <D.22682>, case 38: <D.22675>, case 42: <D.22676>, case 91: <D.22678>>
  <D.22675>:
  if (isbyref != 0) goto <D.28501>; else goto <D.28502>;
  <D.28501>:
  monoeg_g_free (str);
  D.28503 = 0B;
  return D.28503;
  <D.28502>:
  isbyref = 1;
  p = p + 1;
  monoeg_g_free (str);
  D.28504 = &klass->this_arg;
  D.28505 = MEM[(struct MonoObject *)tb].vtable;
  D.28506 = D.28505->domain;
  D.28503 = mono_type_get_object (D.28506, D.28504);
  return D.28503;
  <D.22676>:
  D.28507 = &klass->byval_arg;
  klass = mono_ptr_class_get (D.28507);
  mono_class_init (klass);
  p = p + 1;
  goto <D.22677>;
  <D.22678>:
  rank = 1;
  p = p + 1;
  goto <D.22681>;
  <D.22680>:
  D.28499 = *p;
  if (D.28499 == 93) goto <D.22679>; else goto <D.28508>;
  <D.28508>:
  D.28499 = *p;
  if (D.28499 == 44) goto <D.28509>; else goto <D.28510>;
  <D.28509>:
  rank = rank + 1;
  goto <D.28511>;
  <D.28510>:
  D.28499 = *p;
  if (D.28499 != 42) goto <D.28512>; else goto <D.28513>;
  <D.28512>:
  monoeg_g_free (str);
  D.28503 = 0B;
  return D.28503;
  <D.28513>:
  <D.28511>:
  p = p + 1;
  <D.22681>:
  D.28499 = *p;
  if (D.28499 != 0) goto <D.22680>; else goto <D.22679>;
  <D.22679>:
  D.28499 = *p;
  if (D.28499 != 93) goto <D.28514>; else goto <D.28515>;
  <D.28514>:
  monoeg_g_free (str);
  D.28503 = 0B;
  return D.28503;
  <D.28515>:
  p = p + 1;
  rank.143 = (unsigned int) rank;
  klass = mono_array_class_get (klass, rank.143);
  mono_class_init (klass);
  goto <D.22677>;
  <D.22682>:
  goto <D.22677>;
  <D.22677>:
  <D.22684>:
  D.28499 = *p;
  if (D.28499 != 0) goto <D.22683>; else goto <D.22685>;
  <D.22685>:
  monoeg_g_free (str);
  D.28507 = &klass->byval_arg;
  D.28505 = MEM[(struct MonoObject *)tb].vtable;
  D.28506 = D.28505->domain;
  D.28503 = mono_type_get_object (D.28506, D.28507);
  return D.28503;
}


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.28519;

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


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

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


ves_icall_System_Reflection_AssemblyName_ParseName (struct MonoReflectionAssemblyName * name, struct MonoString * assname)
{
  struct MonoVTable * D.28521;
  int D.28522;
  const mono_byte * D.28525;
  gboolean D.28526;
  int is_token_defined.144;
  int is_version_defined.145;
  struct MonoAssemblyName aname;
  struct MonoDomain * domain;
  char * val;
  gboolean is_version_defined;
  gboolean is_token_defined;

  try
    {
      D.28521 = MEM[(struct MonoObject *)name].vtable;
      domain = D.28521->domain;
      aname.public_key = 0B;
      val = mono_string_to_utf8 (assname);
      D.28522 = mono_assembly_name_parse_full (val, &aname, 1, &is_version_defined, &is_token_defined);
      if (D.28522 == 0) goto <D.28523>; else goto <D.28524>;
      <D.28523>:
      D.28525 = aname.public_key;
      monoeg_g_free (D.28525);
      monoeg_g_free (val);
      D.28526 = 0;
      return D.28526;
      <D.28524>:
      is_token_defined.144 = is_token_defined;
      is_version_defined.145 = is_version_defined;
      fill_reflection_assembly_name (domain, name, &aname, "", is_version_defined.145, 0, is_token_defined.144);
      mono_assembly_name_free (&aname);
      D.28525 = aname.public_key;
      monoeg_g_free (D.28525);
      monoeg_g_free (val);
      D.28526 = 1;
      return D.28526;
    }
  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)
{
  const char * D.28531;
  struct MonoString * D.28532;
  struct MonoString * * D.28533;
  short unsigned int D.28534;
  int D.28535;
  short unsigned int D.28536;
  int D.28537;
  short unsigned int D.28538;
  int D.28539;
  unsigned int D.28540;
  short unsigned int D.28541;
  int D.28542;
  unsigned int D.28543;
  short unsigned int D.28544;
  unsigned int D.28545;
  unsigned int D.28548;
  unsigned int D.28549;
  unsigned int D.28550;
  unsigned int D.28551;
  struct MonoObject * D.28552;
  struct MonoObject * * D.28553;
  char D.28556;
  struct MonoString * D.28561;
  struct MonoString * * D.28562;
  struct MonoMethod * create_culture.146;
  struct MonoImage * D.28566;
  struct MonoMethod * create_culture.147;
  _Bool D.28568;
  long int D.28569;
  long int D.28570;
  const char * D.28573;
  struct MonoString * D.28576;
  struct MonoObject * D.28577;
  struct MonoObject * * D.28578;
  const mono_byte * pkey_ptr.148;
  const char * pkey_ptr.149;
  struct MonoClass * D.28583;
  struct MonoArray * D.28584;
  struct MonoArray * * D.28585;
  struct MonoArray * D.28586;
  char * D.28587;
  unsigned int D.28588;
  unsigned int D.28589;
  struct MonoArray * D.28593;
  unsigned char D.28594;
  struct MonoArray * D.28597;
  struct MonoArray * * D.28598;
  struct MonoArray * D.28599;
  int j.150;
  unsigned char D.28601;
  char D.28602;
  int D.28603;
  int D.28604;
  int D.28605;
  char D.28606;
  int j.151;
  unsigned char D.28608;
  char D.28609;
  int D.28610;
  int D.28611;
  char D.28612;
  char D.28613;
  char D.28614;
  struct MonoArray * D.28618;
  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.28531 = name->name;
      D.28532 = mono_string_new (domain, D.28531);
      D.28533 = &aname->name;
      mono_gc_wbarrier_set_field (aname, D.28533, D.28532);
      D.28534 = name->major;
      D.28535 = (int) D.28534;
      aname->major = D.28535;
      D.28536 = name->minor;
      D.28537 = (int) D.28536;
      aname->minor = D.28537;
      D.28538 = name->build;
      D.28539 = (int) D.28538;
      aname->build = D.28539;
      D.28540 = name->flags;
      aname->flags = D.28540;
      D.28541 = name->revision;
      D.28542 = (int) D.28541;
      aname->revision = D.28542;
      D.28543 = name->hash_alg;
      aname->hashalg = D.28543;
      aname->versioncompat = 1;
      D.28544 = name->arch;
      D.28545 = (unsigned int) D.28544;
      aname->processor_architecture = D.28545;
      if (by_default_version != 0) goto <D.28546>; else goto <D.28547>;
      <D.28546>:
      D.28541 = name->revision;
      D.28548 = (unsigned int) D.28541;
      D.28538 = name->build;
      D.28549 = (unsigned int) D.28538;
      D.28536 = name->minor;
      D.28550 = (unsigned int) D.28536;
      D.28534 = name->major;
      D.28551 = (unsigned int) D.28534;
      D.28552 = create_version (domain, D.28551, D.28550, D.28549, D.28548);
      D.28553 = &aname->version;
      mono_gc_wbarrier_set_field (aname, D.28553, D.28552);
      <D.28547>:
      codebase = 0B;
      if (absolute != 0B) goto <D.28554>; else goto <D.28555>;
      <D.28554>:
      D.28556 = *absolute;
      if (D.28556 != 0) goto <D.28557>; else goto <D.28558>;
      <D.28557>:
      {
        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.28558>:
      <D.28555>:
      if (codebase != 0B) goto <D.28559>; else goto <D.28560>;
      <D.28559>:
      D.28561 = mono_string_new (domain, codebase);
      D.28562 = &aname->codebase;
      mono_gc_wbarrier_set_field (aname, D.28562, D.28561);
      monoeg_g_free (codebase);
      <D.28560>:
      create_culture.146 = create_culture;
      if (create_culture.146 == 0B) goto <D.28564>; else goto <D.28565>;
      <D.28564>:
      {
        struct MonoMethodDesc * desc;

        desc = mono_method_desc_new ("System.Globalization.CultureInfo:CreateCulture(string,bool)", 1);
        D.28566 = mono_defaults.corlib;
        create_culture.147 = mono_method_desc_search_in_image (desc, D.28566);
        create_culture = create_culture.147;
        create_culture.146 = create_culture;
        D.28568 = create_culture.146 == 0B;
        D.28569 = (long int) D.28568;
        D.28570 = __builtin_expect (D.28569, 0);
        if (D.28570 != 0) goto <D.28571>; else goto <D.28572>;
        <D.28571>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "icall.c", 4954, "create_culture");
        <D.28572>:
        mono_method_desc_free (desc);
      }
      <D.28565>:
      D.28573 = name->culture;
      if (D.28573 != 0B) goto <D.28574>; else goto <D.28575>;
      <D.28574>:
      D.28573 = name->culture;
      D.28576 = mono_string_new (domain, D.28573);
      args[0] = D.28576;
      args[1] = &assembly_ref;
      create_culture.146 = create_culture;
      D.28577 = mono_runtime_invoke (create_culture.146, 0B, &args, 0B);
      D.28578 = &aname->cultureInfo;
      mono_gc_wbarrier_set_field (aname, D.28578, D.28577);
      <D.28575>:
      pkey_ptr.148 = name->public_key;
      if (pkey_ptr.148 != 0B) goto <D.28580>; else goto <D.28581>;
      <D.28580>:
      pkey_ptr.148 = name->public_key;
      pkey_ptr = pkey_ptr.148;
      pkey_ptr.149 = pkey_ptr;
      pkey_len = mono_metadata_decode_blob_size (pkey_ptr.149, &pkey_ptr);
      D.28583 = mono_defaults.byte_class;
      D.28584 = mono_array_new (domain, D.28583, pkey_len);
      D.28585 = &aname->publicKey;
      mono_gc_wbarrier_set_field (aname, D.28585, D.28584);
      pkey_ptr.149 = pkey_ptr;
      D.28586 = aname->publicKey;
      D.28587 = mono_array_addr_with_size (D.28586, 1, 0);
      memcpy (D.28587, pkey_ptr.149, pkey_len);
      D.28588 = aname->flags;
      D.28589 = D.28588 | 1;
      aname->flags = D.28589;
      goto <D.28590>;
      <D.28581>:
      if (default_publickey != 0) goto <D.28591>; else goto <D.28592>;
      <D.28591>:
      D.28583 = mono_defaults.byte_class;
      D.28593 = mono_array_new (domain, D.28583, 0);
      D.28585 = &aname->publicKey;
      mono_gc_wbarrier_set_field (aname, D.28585, D.28593);
      D.28588 = aname->flags;
      D.28589 = D.28588 | 1;
      aname->flags = D.28589;
      <D.28592>:
      <D.28590>:
      D.28594 = name->public_key_token[0];
      if (D.28594 != 0) goto <D.28595>; else goto <D.28596>;
      <D.28595>:
      {
        int i;
        int j;
        char * p;

        D.28583 = mono_defaults.byte_class;
        D.28597 = mono_array_new (domain, D.28583, 8);
        D.28598 = &aname->keyToken;
        mono_gc_wbarrier_set_field (aname, D.28598, D.28597);
        D.28599 = aname->keyToken;
        p = mono_array_addr_with_size (D.28599, 1, 0);
        i = 0;
        j = 0;
        goto <D.22426>;
        <D.22425>:
        j.150 = j;
        j = j.150 + 1;
        D.28601 = name->public_key_token[j.150];
        D.28602 = (char) D.28601;
        D.28603 = (int) D.28602;
        D.28604 = monoeg_g_ascii_xdigit_value (D.28603);
        D.28605 = D.28604 << 4;
        D.28606 = (char) D.28605;
        *p = D.28606;
        j.151 = j;
        j = j.151 + 1;
        D.28608 = name->public_key_token[j.151];
        D.28609 = (char) D.28608;
        D.28610 = (int) D.28609;
        D.28611 = monoeg_g_ascii_xdigit_value (D.28610);
        D.28612 = *p;
        D.28613 = (char) D.28611;
        D.28614 = D.28612 | D.28613;
        *p = D.28614;
        p = p + 1;
        i = i + 1;
        <D.22426>:
        if (i <= 7) goto <D.22425>; else goto <D.22427>;
        <D.22427>:
      }
      goto <D.28615>;
      <D.28596>:
      if (default_token != 0) goto <D.28616>; else goto <D.28617>;
      <D.28616>:
      D.28583 = mono_defaults.byte_class;
      D.28618 = mono_array_new (domain, D.28583, 0);
      D.28598 = &aname->keyToken;
      mono_gc_wbarrier_set_field (aname, D.28598, D.28618);
      <D.28617>:
      <D.28615>:
    }
  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.152;
  struct MonoImage * D.28622;
  struct MonoClass * System_Version.153;
  _Bool D.28624;
  long int D.28625;
  long int D.28626;
  struct MonoMethod * create_version.154;
  struct MonoMethod * create_version.155;
  _Bool D.28633;
  long int D.28634;
  long int D.28635;
  struct MonoObject * D.28638;
  static struct MonoClass * System_Version = 0B;
  static struct MonoMethod * create_version = 0B;
  struct MonoObject * result;
  void * args[4];

  try
    {
      System_Version.152 = System_Version;
      if (System_Version.152 == 0B) goto <D.28620>; else goto <D.28621>;
      <D.28620>:
      D.28622 = mono_defaults.corlib;
      System_Version.153 = mono_class_from_name (D.28622, "System", "Version");
      System_Version = System_Version.153;
      System_Version.152 = System_Version;
      D.28624 = System_Version.152 == 0B;
      D.28625 = (long int) D.28624;
      D.28626 = __builtin_expect (D.28625, 0);
      if (D.28626 != 0) goto <D.28627>; else goto <D.28628>;
      <D.28627>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "icall.c", 4404, "System_Version");
      <D.28628>:
      <D.28621>:
      create_version.154 = create_version;
      if (create_version.154 == 0B) goto <D.28630>; else goto <D.28631>;
      <D.28630>:
      {
        struct MonoMethodDesc * desc;

        desc = mono_method_desc_new (":.ctor(int,int,int,int)", 0);
        System_Version.152 = System_Version;
        create_version.155 = mono_method_desc_search_in_class (desc, System_Version.152);
        create_version = create_version.155;
        create_version.154 = create_version;
        D.28633 = create_version.154 == 0B;
        D.28634 = (long int) D.28633;
        D.28635 = __builtin_expect (D.28634, 0);
        if (D.28635 != 0) goto <D.28636>; else goto <D.28637>;
        <D.28636>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "icall.c", 4410, "create_version");
        <D.28637>:
        mono_method_desc_free (desc);
      }
      <D.28631>:
      args[0] = &major;
      args[1] = &minor;
      args[2] = &build;
      args[3] = &revision;
      System_Version.152 = System_Version;
      result = mono_object_new (domain, System_Version.152);
      create_version.154 = create_version;
      mono_runtime_invoke (create_version.154, result, &args, 0B);
      D.28638 = result;
      return D.28638;
    }
  finally
    {
      args = {CLOBBER};
    }
}


ves_icall_System_Reflection_Assembly_load_with_partial_name (struct MonoString * mname, struct MonoObject * evidence)
{
  struct MonoReflectionAssembly * D.28643;
  struct MonoDomain * D.28644;
  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.28641>; else goto <D.28642>;
      <D.28641>:
      D.28643 = 0B;
      return D.28643;
      <D.28642>:
      D.28644 = mono_domain_get ();
      D.28643 = mono_assembly_get_object (D.28644, res);
      return D.28643;
    }
  finally
    {
      status = {CLOBBER};
    }
}


ves_icall_System_Reflection_Assembly_get_location (struct MonoReflectionAssembly * assembly)
{
  struct MonoVTable * D.28647;
  struct MonoAssembly * D.28648;
  struct MonoImage * D.28649;
  const char * D.28650;
  struct MonoString * D.28651;
  struct MonoDomain * domain;
  struct MonoString * res;

  D.28647 = MEM[(struct MonoObject *)assembly].vtable;
  domain = D.28647->domain;
  D.28648 = assembly->assembly;
  D.28649 = D.28648->image;
  D.28650 = mono_image_get_filename (D.28649);
  res = mono_string_new (domain, D.28650);
  D.28651 = res;
  return D.28651;
}


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

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


ves_icall_System_Reflection_Assembly_get_fullName (struct MonoReflectionAssembly * assembly)
{
  struct MonoVTable * D.28655;
  struct MonoAssemblyName * D.28656;
  struct MonoString * D.28657;
  struct MonoDomain * domain;
  struct MonoAssembly * mass;
  struct MonoString * res;
  gchar * name;

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


ves_icall_System_Reflection_Assembly_get_code_base (struct MonoReflectionAssembly * assembly, MonoBoolean escaped)
{
  struct MonoVTable * D.28659;
  struct MonoImage * D.28660;
  char * D.28661;
  int D.28662;
  gchar * absolute.156;
  gchar * absolute.157;
  char * D.28668;
  gchar * absolute.158;
  struct MonoString * D.28675;
  struct MonoDomain * domain;
  struct MonoAssembly * mass;
  struct MonoString * res;
  gchar * uri;
  gchar * absolute;
  gchar * dirname;

  try
    {
      D.28659 = MEM[(struct MonoObject *)assembly].vtable;
      domain = D.28659->domain;
      mass = assembly->assembly;
      res = 0B;
      D.28660 = mass->image;
      D.28661 = D.28660->name;
      D.28662 = monoeg_g_path_is_absolute (D.28661);
      if (D.28662 != 0) goto <D.28663>; else goto <D.28664>;
      <D.28663>:
      D.28660 = mass->image;
      D.28661 = D.28660->name;
      absolute.156 = monoeg_strdup (D.28661);
      absolute = absolute.156;
      absolute.157 = absolute;
      dirname = monoeg_g_path_get_dirname (absolute.157);
      goto <D.28667>;
      <D.28664>:
      D.28660 = mass->image;
      D.28661 = D.28660->name;
      D.28668 = mass->basedir;
      absolute.158 = monoeg_g_build_path ("/", D.28668, D.28661, 0B);
      absolute = absolute.158;
      D.28668 = mass->basedir;
      dirname = monoeg_strdup (D.28668);
      <D.28667>:
      replace_shadow_path (domain, dirname, &absolute);
      monoeg_g_free (dirname);
      if (escaped != 0) goto <D.28670>; else goto <D.28671>;
      <D.28670>:
      absolute.157 = absolute;
      uri = monoeg_g_filename_to_uri (absolute.157, 0B, 0B);
      goto <D.28672>;
      <D.28671>:
      {
        const char * prepend;

        prepend = "file://";
        absolute.157 = absolute;
        uri = monoeg_g_strconcat (prepend, absolute.157, 0B);
      }
      <D.28672>:
      if (uri != 0B) goto <D.28673>; else goto <D.28674>;
      <D.28673>:
      res = mono_string_new (domain, uri);
      monoeg_g_free (uri);
      <D.28674>:
      absolute.157 = absolute;
      monoeg_g_free (absolute.157);
      D.28675 = res;
      return D.28675;
    }
  finally
    {
      absolute = {CLOBBER};
    }
}


replace_shadow_path (struct MonoDomain * domain, gchar * dirname, gchar * * filename)
{
  int D.28678;
  int D.28683;
  gchar * content.159;
  int D.28686;
  gchar * D.28691;
  gboolean D.28694;
  gchar * content;
  gchar * shadow_ini_file;
  gsize len;

  try
    {
      D.28678 = mono_is_shadow_copy_enabled (domain, dirname);
      if (D.28678 != 0) goto <D.28679>; else goto <D.28680>;
      <D.28679>:
      shadow_ini_file = monoeg_g_build_path ("/", dirname, "__AssemblyInfo__.ini", 0B);
      content = 0B;
      D.28683 = monoeg_g_file_get_contents (shadow_ini_file, &content, &len, 0B);
      if (D.28683 == 0) goto <D.28681>; else goto <D.28684>;
      <D.28684>:
      content.159 = content;
      D.28686 = monoeg_g_file_test (content.159, 1);
      if (D.28686 == 0) goto <D.28681>; else goto <D.28682>;
      <D.28681>:
      content.159 = content;
      if (content.159 != 0B) goto <D.28687>; else goto <D.28688>;
      <D.28687>:
      content.159 = content;
      monoeg_g_free (content.159);
      content = 0B;
      <D.28688>:
      <D.28682>:
      monoeg_g_free (shadow_ini_file);
      content.159 = content;
      if (content.159 != 0B) goto <D.28689>; else goto <D.28690>;
      <D.28689>:
      D.28691 = *filename;
      if (D.28691 != 0B) goto <D.28692>; else goto <D.28693>;
      <D.28692>:
      D.28691 = *filename;
      monoeg_g_free (D.28691);
      <D.28693>:
      content.159 = content;
      *filename = content.159;
      D.28694 = 1;
      return D.28694;
      <D.28690>:
      <D.28680>:
      D.28694 = 0;
      return D.28694;
    }
  finally
    {
      content = {CLOBBER};
      len = {CLOBBER};
    }
}


ves_icall_System_Reflection_Assembly_get_ReflectionOnly (struct MonoReflectionAssembly * assembly)
{
  MonoBoolean D.28697;
  struct MonoAssembly * D.28698;
  int D.28699;

  D.28698 = assembly->assembly;
  D.28699 = D.28698->ref_only;
  D.28697 = (MonoBoolean) D.28699;
  return D.28697;
}


ves_icall_System_Reflection_Assembly_get_EntryPoint (struct MonoReflectionAssembly * assembly)
{
  struct MonoAssembly * D.28701;
  struct MonoImage * D.28702;
  struct MonoReflectionMethod * D.28705;
  struct MonoMethod * D.28706;
  struct MonoVTable * D.28707;
  struct MonoDomain * D.28708;
  guint32 token;

  D.28701 = assembly->assembly;
  D.28702 = D.28701->image;
  token = mono_image_get_entry_point (D.28702);
  if (token == 0) goto <D.28703>; else goto <D.28704>;
  <D.28703>:
  D.28705 = 0B;
  return D.28705;
  <D.28704>:
  D.28701 = assembly->assembly;
  D.28702 = D.28701->image;
  D.28706 = mono_get_method (D.28702, token, 0B);
  D.28707 = MEM[(struct MonoObject *)assembly].vtable;
  D.28708 = D.28707->domain;
  D.28705 = mono_method_get_object (D.28708, D.28706, 0B);
  return D.28705;
}


ves_icall_MonoDebugger_GetMethodToken (struct MonoReflectionMethod * method)
{
  gint32 D.28710;
  struct MonoMethod * D.28711;
  unsigned int D.28712;

  D.28711 = method->method;
  D.28712 = D.28711->token;
  D.28710 = (gint32) D.28712;
  return D.28710;
}


ves_icall_System_Reflection_Assembly_LoadPermissions (struct MonoReflectionAssembly * assembly, char * * minimum, guint32 * minLength, char * * optional, guint32 * optLength, char * * refused, guint32 * refLength)
{
  struct MonoAssembly * D.28714;
  unsigned char D.28715;
  char * D.28718;
  unsigned int D.28719;
  unsigned char D.28720;
  unsigned char D.28723;
  MonoBoolean D.28726;
  MonoBoolean result;
  struct MonoDeclSecurityEntry entry;

  try
    {
      result = 0;
      D.28714 = assembly->assembly;
      D.28715 = mono_declsec_get_assembly_action (D.28714, 8, &entry);
      if (D.28715 != 0) goto <D.28716>; else goto <D.28717>;
      <D.28716>:
      D.28718 = entry.blob;
      *minimum = D.28718;
      D.28719 = entry.size;
      *minLength = D.28719;
      result = 1;
      <D.28717>:
      D.28714 = assembly->assembly;
      D.28720 = mono_declsec_get_assembly_action (D.28714, 9, &entry);
      if (D.28720 != 0) goto <D.28721>; else goto <D.28722>;
      <D.28721>:
      D.28718 = entry.blob;
      *optional = D.28718;
      D.28719 = entry.size;
      *optLength = D.28719;
      result = 1;
      <D.28722>:
      D.28714 = assembly->assembly;
      D.28723 = mono_declsec_get_assembly_action (D.28714, 10, &entry);
      if (D.28723 != 0) goto <D.28724>; else goto <D.28725>;
      <D.28724>:
      D.28718 = entry.blob;
      *refused = D.28718;
      D.28719 = entry.size;
      *refLength = D.28719;
      result = 1;
      <D.28725>:
      D.28726 = result;
      return D.28726;
    }
  finally
    {
      entry = {CLOBBER};
    }
}


ves_icall_System_Reflection_Assembly_InternalImageRuntimeVersion (struct MonoReflectionAssembly * assembly)
{
  struct MonoVTable * D.28729;
  struct MonoString * D.28730;
  struct MonoAssembly * D.28731;
  struct MonoImage * D.28732;
  char * D.28733;
  struct MonoDomain * domain;

  D.28729 = MEM[(struct MonoObject *)assembly].vtable;
  domain = D.28729->domain;
  D.28731 = assembly->assembly;
  D.28732 = D.28731->image;
  D.28733 = D.28732->version;
  D.28730 = mono_string_new (domain, D.28733);
  return D.28730;
}


ves_icall_System_Reflection_Assembly_InternalGetType (struct MonoReflectionAssembly * assembly, struct MonoReflectionModule * module, struct MonoString * name, MonoBoolean throwOnError, MonoBoolean ignoreCase)
{
  int D.28735;
  struct MonoException * D.28740;
  struct MonoReflectionType * D.28741;
  const char * D.28742;
  struct MonoClass * D.28747;
  struct MonoException * D.28750;
  struct MonoException * D.28752;
  struct MonoImage * D.28755;
  int D.28758;
  struct MonoAssembly * D.28761;
  unsigned char D.28762;
  struct MonoArray * D.28765;
  unsigned int i.160;
  char * D.28769;
  struct MonoDynamicImage * D.28770;
  struct MonoImage * D.28771;
  unsigned int D.28773;
  struct MonoArray * D.28776;
  char * D.28779;
  struct MonoImage * D.28780;
  unsigned int D.28782;
  struct MonoImage * D.28784;
  struct MonoLoaderError * D.28789;
  struct MonoLoaderError * D.28794;
  struct MonoLoaderError * D.28797;
  struct MonoLoaderError * D.28802;
  struct MonoException * D.28803;
  unsigned char D.28804;
  int D.28807;
  unsigned char D.28810;
  int D.28817;
  struct MonoVTable * D.28822;
  struct MonoDomain * D.28823;
  gchar * str;
  struct MonoType * type;
  struct MonoTypeNameParse info;
  gboolean type_resolve;

  try
    {
      type = 0B;
      type_resolve = 1;
      str = mono_string_to_utf8 (name);
      D.28735 = mono_reflection_parse_type (str, &info);
      if (D.28735 == 0) goto <D.28736>; else goto <D.28737>;
      <D.28736>:
      monoeg_g_free (str);
      mono_reflection_free_type_info (&info);
      if (throwOnError != 0) goto <D.28738>; else goto <D.28739>;
      <D.28738>:
      D.28740 = mono_get_exception_type_load (name, 0B);
      mono_raise_exception (D.28740);
      <D.28739>:
      D.28741 = 0B;
      return D.28741;
      <D.28737>:
      D.28742 = info.assembly.name;
      if (D.28742 != 0B) goto <D.28743>; else goto <D.28744>;
      <D.28743>:
      monoeg_g_free (str);
      mono_reflection_free_type_info (&info);
      if (throwOnError != 0) goto <D.28745>; else goto <D.28746>;
      <D.28745>:
      D.28747 = mono_defaults.generic_ilist_class;
      if (D.28747 != 0B) goto <D.28748>; else goto <D.28749>;
      <D.28748>:
      D.28750 = mono_get_exception_argument (0B, "Type names passed to Assembly.GetType() must not specify an assembly.");
      mono_raise_exception (D.28750);
      goto <D.28751>;
      <D.28749>:
      D.28752 = mono_get_exception_type_load (name, 0B);
      mono_raise_exception (D.28752);
      <D.28751>:
      <D.28746>:
      D.28741 = 0B;
      return D.28741;
      <D.28744>:
      if (module != 0B) goto <D.28753>; else goto <D.28754>;
      <D.28753>:
      D.28755 = module->image;
      if (D.28755 != 0B) goto <D.28756>; else goto <D.28757>;
      <D.28756>:
      D.28758 = (int) ignoreCase;
      D.28755 = module->image;
      type = mono_reflection_get_type (D.28755, &info, D.28758, &type_resolve);
      goto <D.28759>;
      <D.28757>:
      type = 0B;
      <D.28759>:
      goto <D.28760>;
      <D.28754>:
      D.28761 = assembly->assembly;
      D.28762 = D.28761->dynamic;
      if (D.28762 != 0) goto <D.28763>; else goto <D.28764>;
      <D.28763>:
      {
        struct MonoReflectionAssemblyBuilder * abuilder;
        int i;

        abuilder = assembly;
        type = 0B;
        D.28765 = abuilder->modules;
        if (D.28765 != 0B) goto <D.28766>; else goto <D.28767>;
        <D.28766>:
        i = 0;
        goto <D.22127>;
        <D.22126>:
        {
          struct MonoReflectionModuleBuilder * mb;

          i.160 = (unsigned int) i;
          D.28765 = abuilder->modules;
          D.28769 = mono_array_addr_with_size (D.28765, 4, i.160);
          mb = MEM[(struct MonoReflectionModuleBuilder * *)D.28769];
          D.28758 = (int) ignoreCase;
          D.28770 = mb->dynamic_image;
          D.28771 = &D.28770->image;
          type = mono_reflection_get_type (D.28771, &info, D.28758, &type_resolve);
          if (type != 0B) goto <D.22125>; else goto <D.28772>;
          <D.28772>:
        }
        i = i + 1;
        <D.22127>:
        i.160 = (unsigned int) i;
        D.28765 = abuilder->modules;
        D.28773 = mono_array_length (D.28765);
        if (i.160 < D.28773) goto <D.22126>; else goto <D.22125>;
        <D.22125>:
        <D.28767>:
        if (type == 0B) goto <D.28774>; else goto <D.28775>;
        <D.28774>:
        D.28776 = abuilder->loaded_modules;
        if (D.28776 != 0B) goto <D.28777>; else goto <D.28778>;
        <D.28777>:
        i = 0;
        goto <D.22131>;
        <D.22130>:
        {
          struct MonoReflectionModule * mod;

          i.160 = (unsigned int) i;
          D.28776 = abuilder->loaded_modules;
          D.28779 = mono_array_addr_with_size (D.28776, 4, i.160);
          mod = MEM[(struct MonoReflectionModule * *)D.28779];
          D.28758 = (int) ignoreCase;
          D.28780 = mod->image;
          type = mono_reflection_get_type (D.28780, &info, D.28758, &type_resolve);
          if (type != 0B) goto <D.22129>; else goto <D.28781>;
          <D.28781>:
        }
        i = i + 1;
        <D.22131>:
        i.160 = (unsigned int) i;
        D.28776 = abuilder->loaded_modules;
        D.28782 = mono_array_length (D.28776);
        if (i.160 < D.28782) goto <D.22130>; else goto <D.22129>;
        <D.22129>:
        <D.28778>:
        <D.28775>:
      }
      goto <D.28783>;
      <D.28764>:
      D.28758 = (int) ignoreCase;
      D.28761 = assembly->assembly;
      D.28784 = D.28761->image;
      type = mono_reflection_get_type (D.28784, &info, D.28758, &type_resolve);
      <D.28783>:
      <D.28760>:
      monoeg_g_free (str);
      mono_reflection_free_type_info (&info);
      if (type == 0B) goto <D.28785>; else goto <D.28786>;
      <D.28785>:
      {
        struct MonoException * e;

        e = 0B;
        if (throwOnError != 0) goto <D.28787>; else goto <D.28788>;
        <D.28787>:
        e = mono_get_exception_type_load (name, 0B);
        <D.28788>:
        D.28789 = mono_loader_get_last_error ();
        if (D.28789 != 0B) goto <D.28790>; else goto <D.28791>;
        <D.28790>:
        D.28747 = mono_defaults.generic_ilist_class;
        if (D.28747 != 0B) goto <D.28792>; else goto <D.28793>;
        <D.28792>:
        D.28794 = mono_loader_get_last_error ();
        e = mono_loader_error_prepare_exception (D.28794);
        <D.28793>:
        <D.28791>:
        mono_loader_clear_error ();
        if (e != 0B) goto <D.28795>; else goto <D.28796>;
        <D.28795>:
        mono_raise_exception (e);
        <D.28796>:
        D.28741 = 0B;
        return D.28741;
      }
      <D.28786>:
      D.28797 = mono_loader_get_last_error ();
      if (D.28797 != 0B) goto <D.28798>; else goto <D.28799>;
      <D.28798>:
      if (throwOnError != 0) goto <D.28800>; else goto <D.28801>;
      <D.28800>:
      D.28802 = mono_loader_get_last_error ();
      D.28803 = mono_loader_error_prepare_exception (D.28802);
      mono_raise_exception (D.28803);
      <D.28801>:
      mono_loader_clear_error ();
      <D.28799>:
      D.28804 = type->type;
      if (D.28804 == 18) goto <D.28805>; else goto <D.28806>;
      <D.28805>:
      {
        struct MonoClass * klass;

        klass = mono_type_get_class (type);
        D.28807 = mono_is_security_manager_active ();
        if (D.28807 != 0) goto <D.28808>; else goto <D.28809>;
        <D.28808>:
        D.28810 = klass->exception_type;
        if (D.28810 == 0) goto <D.28811>; else goto <D.28812>;
        <D.28811>:
        mono_class_setup_vtable (klass);
        <D.28812>:
        <D.28809>:
        if (throwOnError != 0) goto <D.28815>; else goto <D.28813>;
        <D.28815>:
        D.28810 = klass->exception_type;
        if (D.28810 != 0) goto <D.28816>; else goto <D.28813>;
        <D.28816>:
        {
          struct MonoException * exc;

          exc = mono_class_get_exception_for_failure (klass);
          mono_loader_clear_error ();
          mono_raise_exception (exc);
        }
        goto <D.28814>;
        <D.28813>:
        D.28817 = mono_is_security_manager_active ();
        if (D.28817 != 0) goto <D.28818>; else goto <D.28819>;
        <D.28818>:
        D.28810 = klass->exception_type;
        if (D.28810 == 2) goto <D.28820>; else goto <D.28821>;
        <D.28820>:
        D.28741 = 0B;
        return D.28741;
        <D.28821>:
        <D.28819>:
        <D.28814>:
      }
      <D.28806>:
      D.28822 = MEM[(struct MonoObject *)assembly].vtable;
      D.28823 = D.28822->domain;
      D.28741 = mono_type_get_object (D.28823, type);
      return D.28741;
    }
  finally
    {
      info = {CLOBBER};
      type_resolve = {CLOBBER};
    }
}


ves_icall_System_Reflection_Assembly_InternalGetAssemblyName (struct MonoString * fname, struct MonoReflectionAssemblyName * aname)
{
  char * filename.161;
  char * filename.162;
  struct MonoDomain * D.28828;
  <unnamed type> status.163;
  struct MonoException * D.28837;
  struct MonoDomain * D.28838;
  char * filename;
  MonoImageOpenStatus status;
  gboolean res;
  struct MonoImage * image;
  struct MonoAssemblyName name;
  char * dirname;

  try
    {
      status = 0;
      filename.161 = mono_string_to_utf8 (fname);
      filename = filename.161;
      filename.162 = filename;
      dirname = monoeg_g_path_get_dirname (filename.162);
      D.28828 = mono_domain_get ();
      replace_shadow_path (D.28828, dirname, &filename);
      monoeg_g_free (dirname);
      filename.162 = filename;
      image = mono_image_open (filename.162, &status);
      if (image == 0B) goto <D.28829>; else goto <D.28830>;
      <D.28829>:
      {
        struct MonoException * exc;

        filename.162 = filename;
        monoeg_g_free (filename.162);
        status.163 = status;
        if (status.163 == 3) goto <D.28832>; else goto <D.28833>;
        <D.28832>:
        exc = mono_get_exception_bad_image_format2 (0B, fname);
        goto <D.28834>;
        <D.28833>:
        exc = mono_get_exception_file_not_found2 (0B, fname);
        <D.28834>:
        mono_raise_exception (exc);
      }
      <D.28830>:
      res = mono_assembly_fill_assembly_name (image, &name);
      if (res == 0) goto <D.28835>; else goto <D.28836>;
      <D.28835>:
      mono_image_close (image);
      filename.162 = filename;
      monoeg_g_free (filename.162);
      D.28837 = mono_get_exception_argument ("assemblyFile", "The file does not contain a manifest");
      mono_raise_exception (D.28837);
      <D.28836>:
      filename.162 = filename;
      D.28838 = mono_domain_get ();
      fill_reflection_assembly_name (D.28838, aname, &name, filename.162, 1, 0, 1);
      filename.162 = filename;
      monoeg_g_free (filename.162);
      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.28839;
  struct MonoAssembly * D.28840;
  unsigned char D.28841;
  _Bool D.28842;
  long int D.28843;
  long int D.28844;
  int D.28847;
  unsigned int D.28848;
  unsigned int D.28849;
  int D.28852;
  unsigned int D.28853;
  struct MonoAssembly * D.28854;
  unsigned int D.28857;
  unsigned int D.28860;
  struct MonoClass * D.28861;
  int len1.164;
  int len2.165;
  struct MonoArray * exceptions.166;
  struct MonoArray * ex2.167;
  <unnamed-unsigned:24> D.28866;
  int D.28867;
  unsigned int D.28868;
  unsigned int i.168;
  char * D.28870;
  struct MonoType * D.28873;
  unsigned char D.28876;
  _Bool D.28880;
  _Bool D.28881;
  _Bool D.28882;
  unsigned int D.28885;
  unsigned int ex_count.169;
  unsigned int D.28887;
  unsigned int length.170;
  struct MonoClass * D.28889;
  void * D.28890;
  unsigned int j.171;
  char * D.28892;
  _Bool D.28895;
  long int D.28896;
  long int D.28897;
  unsigned int D.28900;
  struct MonoArray * D.28901;
  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.28839 = MEM[(struct MonoObject *)assembly].vtable;
      domain = D.28839->domain;
      D.28840 = assembly->assembly;
      D.28841 = D.28840->dynamic;
      D.28842 = D.28841 != 0;
      D.28843 = (long int) D.28842;
      D.28844 = __builtin_expect (D.28843, 0);
      if (D.28844 != 0) goto <D.28845>; else goto <D.28846>;
      <D.28845>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "icall.c", 5171, "!assembly->assembly->dynamic");
      <D.28846>:
      D.28840 = assembly->assembly;
      image = D.28840->image;
      table = &image->tables[38];
      D.28847 = (int) exportedOnly;
      res = mono_module_get_types (domain, image, &exceptions, D.28847);
      i = 0;
      goto <D.22515>;
      <D.22514>:
      D.28848 = mono_metadata_decode_row_col (table, i, 0);
      D.28849 = D.28848 & 1;
      if (D.28849 == 0) goto <D.28850>; else goto <D.28851>;
      <D.28850>:
      {
        struct MonoImage * loaded_image;

        D.28852 = i + 1;
        D.28853 = (unsigned int) D.28852;
        D.28854 = image->assembly;
        loaded_image = mono_assembly_load_module (D.28854, D.28853);
        if (loaded_image != 0B) goto <D.28855>; else goto <D.28856>;
        <D.28855>:
        {
          struct MonoArray * ex2;
          struct MonoArray * res2;

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

                len1 = mono_array_length (res);
                len2 = mono_array_length (res2);
                D.28860 = len1 + len2;
                D.28861 = mono_defaults.monotype_class;
                res3 = mono_array_new (domain, D.28861, D.28860);
                {
                  void * * __p;
                  void * * __s;

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

                  __p = mono_array_addr_with_size (res3, 4, len1);
                  __s = mono_array_addr_with_size (res2, 4, 0);
                  len2.165 = (int) len2;
                  mono_gc_wbarrier_arrayref_copy (__p, __s, len2.165);
                }
                res = res3;
                D.28860 = len1 + len2;
                D.28861 = mono_defaults.monotype_class;
                ex3 = mono_array_new (domain, D.28861, D.28860);
                {
                  void * * __p;
                  void * * __s;

                  __p = mono_array_addr_with_size (ex3, 4, 0);
                  exceptions.166 = exceptions;
                  __s = mono_array_addr_with_size (exceptions.166, 4, 0);
                  len1.164 = (int) len1;
                  mono_gc_wbarrier_arrayref_copy (__p, __s, len1.164);
                }
                {
                  void * * __p;
                  void * * __s;

                  __p = mono_array_addr_with_size (ex3, 4, len1);
                  ex2.167 = ex2;
                  __s = mono_array_addr_with_size (ex2.167, 4, 0);
                  len2.165 = (int) len2;
                  mono_gc_wbarrier_arrayref_copy (__p, __s, len2.165);
                }
                exceptions = ex3;
              }
              <D.28859>:
            }
          finally
            {
              ex2 = {CLOBBER};
            }
        }
        <D.28856>:
      }
      <D.28851>:
      i = i + 1;
      <D.22515>:
      D.28866 = table->rows;
      D.28867 = (int) D.28866;
      if (D.28867 > i) goto <D.22514>; else goto <D.22516>;
      <D.22516>:
      D.28868 = mono_array_length (res);
      len = (int) D.28868;
      ex_count = 0;
      i = 0;
      goto <D.22521>;
      <D.22520>:
      {
        struct MonoReflectionType * t;
        struct MonoClass * klass;

        i.168 = (unsigned int) i;
        D.28870 = mono_array_addr_with_size (res, 4, i.168);
        t = MEM[(void * *)D.28870];
        if (t != 0B) goto <D.28871>; else goto <D.28872>;
        <D.28871>:
        D.28873 = t->type;
        klass = mono_type_get_class (D.28873);
        if (klass != 0B) goto <D.28874>; else goto <D.28875>;
        <D.28874>:
        D.28876 = klass->exception_type;
        if (D.28876 != 0) goto <D.28877>; else goto <D.28878>;
        <D.28877>:
        list = monoeg_g_list_append (list, klass);
        {
          void * * __p;

          i.168 = (unsigned int) i;
          __p = mono_array_addr_with_size (res, 4, i.168);
          mono_gc_wbarrier_set_arrayref (res, __p, 0B);
        }
        <D.28878>:
        <D.28875>:
        goto <D.28879>;
        <D.28872>:
        ex_count = ex_count + 1;
        <D.28879>:
      }
      i = i + 1;
      <D.22521>:
      if (i < len) goto <D.22520>; else goto <D.22522>;
      <D.22522>:
      D.28880 = list != 0B;
      D.28881 = ex_count != 0;
      D.28882 = D.28880 | D.28881;
      if (D.28882 != 0) goto <D.28883>; else goto <D.28884>;
      <D.28883>:
      {
        struct GList * tmp;
        struct MonoException * exc;
        struct MonoArray * exl;
        int j;
        int length;

        tmp = 0B;
        exc = 0B;
        exl = 0B;
        D.28885 = monoeg_g_list_length (list);
        ex_count.169 = (unsigned int) ex_count;
        D.28887 = D.28885 + ex_count.169;
        length = (int) D.28887;
        mono_loader_clear_error ();
        length.170 = (unsigned int) length;
        D.28889 = mono_defaults.exception_class;
        exl = mono_array_new (domain, D.28889, length.170);
        i = 0;
        tmp = list;
        goto <D.22531>;
        <D.22530>:
        {
          struct MonoException * exc;

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

            i.168 = (unsigned int) i;
            __p = mono_array_addr_with_size (exl, 4, i.168);
            mono_gc_wbarrier_set_arrayref (exl, __p, exc);
          }
        }
        i = i + 1;
        tmp = tmp->next;
        <D.22531>:
        if (tmp != 0B) goto <D.22530>; else goto <D.22532>;
        <D.22532>:
        j = 0;
        goto <D.22536>;
        <D.22535>:
        {
          struct MonoException * exc;

          j.171 = (unsigned int) j;
          exceptions.166 = exceptions;
          D.28892 = mono_array_addr_with_size (exceptions.166, 4, j.171);
          exc = MEM[(struct MonoException * *)D.28892];
          if (exc != 0B) goto <D.28893>; else goto <D.28894>;
          <D.28893>:
          D.28895 = i >= length;
          D.28896 = (long int) D.28895;
          D.28897 = __builtin_expect (D.28896, 0);
          if (D.28897 != 0) goto <D.28898>; else goto <D.28899>;
          <D.28898>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "icall.c", 5248, "i < length");
          <D.28899>:
          {
            void * * __p;

            i.168 = (unsigned int) i;
            __p = mono_array_addr_with_size (exl, 4, i.168);
            mono_gc_wbarrier_set_arrayref (exl, __p, exc);
          }
          i = i + 1;
          <D.28894>:
        }
        j = j + 1;
        <D.22536>:
        j.171 = (unsigned int) j;
        exceptions.166 = exceptions;
        D.28900 = mono_array_length (exceptions.166);
        if (j.171 < D.28900) goto <D.22535>; else goto <D.22537>;
        <D.22537>:
        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.28884>:
      D.28901 = res;
      return D.28901;
    }
  finally
    {
      exceptions = {CLOBBER};
    }
}


ves_icall_System_Reflection_Assembly_GetReferencedAssemblies (struct MonoReflectionAssembly * assembly)
{
  struct MonoVTable * D.28904;
  struct MonoAssembly * D.28905;
  struct MonoClass * System_Reflection_AssemblyName.172;
  struct MonoImage * D.28909;
  struct MonoClass * System_Reflection_AssemblyName.173;
  struct MonoImage * D.28911;
  <unnamed-unsigned:24> D.28912;
  unsigned int count.174;
  struct MonoMethod * create_culture.175;
  struct MonoMethod * create_culture.176;
  _Bool D.28920;
  long int D.28921;
  long int D.28922;
  unsigned int D.28925;
  const char * D.28926;
  struct MonoString * D.28927;
  struct MonoString * * D.28928;
  unsigned int D.28929;
  int D.28930;
  unsigned int D.28931;
  int D.28932;
  unsigned int D.28933;
  int D.28934;
  unsigned int D.28935;
  int D.28936;
  unsigned int D.28937;
  int D.28938;
  unsigned int D.28939;
  int D.28940;
  unsigned int D.28941;
  int D.28942;
  unsigned int D.28943;
  int D.28944;
  unsigned int D.28945;
  struct MonoObject * D.28946;
  struct MonoObject * * D.28947;
  unsigned int D.28950;
  const char * D.28951;
  struct MonoString * D.28952;
  struct MonoObject * D.28953;
  struct MonoObject * * D.28954;
  unsigned int D.28955;
  const char * pkey_ptr.177;
  const gchar * pkey_ptr.178;
  unsigned int D.28960;
  struct MonoClass * D.28963;
  struct MonoArray * D.28964;
  struct MonoArray * * D.28965;
  struct MonoArray * D.28966;
  char * D.28967;
  struct MonoArray * D.28969;
  struct MonoArray * * D.28970;
  struct MonoArray * D.28971;
  char * D.28972;
  struct MonoArray * D.28974;
  unsigned int i.179;
  struct MonoArray * D.28976;
  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.28904 = MEM[(struct MonoObject *)assembly].vtable;
  domain = D.28904->domain;
  count = 0;
  D.28905 = assembly->assembly;
  image = D.28905->image;
  System_Reflection_AssemblyName.172 = System_Reflection_AssemblyName;
  if (System_Reflection_AssemblyName.172 == 0B) goto <D.28907>; else goto <D.28908>;
  <D.28907>:
  D.28909 = mono_defaults.corlib;
  System_Reflection_AssemblyName.173 = mono_class_from_name (D.28909, "System.Reflection", "AssemblyName");
  System_Reflection_AssemblyName = System_Reflection_AssemblyName.173;
  <D.28908>:
  D.28905 = assembly->assembly;
  D.28911 = D.28905->image;
  t = &D.28911->tables[35];
  D.28912 = t->rows;
  count = (int) D.28912;
  count.174 = (unsigned int) count;
  System_Reflection_AssemblyName.172 = System_Reflection_AssemblyName;
  result = mono_array_new (domain, System_Reflection_AssemblyName.172, count.174);
  if (count > 0) goto <D.28914>; else goto <D.28915>;
  <D.28914>:
  create_culture.175 = create_culture;
  if (create_culture.175 == 0B) goto <D.28917>; else goto <D.28918>;
  <D.28917>:
  {
    struct MonoMethodDesc * desc;

    desc = mono_method_desc_new ("System.Globalization.CultureInfo:CreateCulture(string,bool)", 1);
    D.28909 = mono_defaults.corlib;
    create_culture.176 = mono_method_desc_search_in_image (desc, D.28909);
    create_culture = create_culture.176;
    create_culture.175 = create_culture;
    D.28920 = create_culture.175 == 0B;
    D.28921 = (long int) D.28920;
    D.28922 = __builtin_expect (D.28921, 0);
    if (D.28922 != 0) goto <D.28923>; else goto <D.28924>;
    <D.28923>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "icall.c", 4450, "create_culture");
    <D.28924>:
    mono_method_desc_free (desc);
  }
  <D.28918>:
  <D.28915>:
  i = 0;
  goto <D.22227>;
  <D.22226>:
  {
    struct MonoReflectionAssemblyName * aname;
    guint32 cols[9];

    try
      {
        mono_metadata_decode_row (t, i, &cols, 9);
        System_Reflection_AssemblyName.172 = System_Reflection_AssemblyName;
        aname = mono_object_new (domain, System_Reflection_AssemblyName.172);
        D.28925 = cols[6];
        D.28926 = mono_metadata_string_heap (image, D.28925);
        D.28927 = mono_string_new (domain, D.28926);
        D.28928 = &aname->name;
        mono_gc_wbarrier_set_field (aname, D.28928, D.28927);
        D.28929 = cols[0];
        D.28930 = (int) D.28929;
        aname->major = D.28930;
        D.28931 = cols[1];
        D.28932 = (int) D.28931;
        aname->minor = D.28932;
        D.28933 = cols[2];
        D.28934 = (int) D.28933;
        aname->build = D.28934;
        D.28935 = cols[3];
        D.28936 = (int) D.28935;
        aname->revision = D.28936;
        D.28937 = cols[4];
        aname->flags = D.28937;
        aname->versioncompat = 1;
        aname->hashalg = 32772;
        D.28938 = aname->revision;
        D.28939 = (unsigned int) D.28938;
        D.28940 = aname->build;
        D.28941 = (unsigned int) D.28940;
        D.28942 = aname->minor;
        D.28943 = (unsigned int) D.28942;
        D.28944 = aname->major;
        D.28945 = (unsigned int) D.28944;
        D.28946 = create_version (domain, D.28945, D.28943, D.28941, D.28939);
        D.28947 = &aname->version;
        mono_gc_wbarrier_set_field (aname, D.28947, D.28946);
        create_culture.175 = create_culture;
        if (create_culture.175 != 0B) goto <D.28948>; else goto <D.28949>;
        <D.28948>:
        {
          void * args[2];
          MonoBoolean assembly_ref;

          try
            {
              assembly_ref = 1;
              D.28950 = cols[7];
              D.28951 = mono_metadata_string_heap (image, D.28950);
              D.28952 = mono_string_new (domain, D.28951);
              args[0] = D.28952;
              args[1] = &assembly_ref;
              create_culture.175 = create_culture;
              D.28953 = mono_runtime_invoke (create_culture.175, 0B, &args, 0B);
              D.28954 = &aname->cultureInfo;
              mono_gc_wbarrier_set_field (aname, D.28954, D.28953);
            }
          finally
            {
              args = {CLOBBER};
              assembly_ref = {CLOBBER};
            }
        }
        <D.28949>:
        D.28955 = cols[5];
        if (D.28955 != 0) goto <D.28956>; else goto <D.28957>;
        <D.28956>:
        {
          const gchar * pkey_ptr;
          guint32 pkey_len;

          try
            {
              D.28955 = cols[5];
              pkey_ptr.177 = mono_metadata_blob_heap (image, D.28955);
              pkey_ptr = pkey_ptr.177;
              pkey_ptr.178 = pkey_ptr;
              pkey_len = mono_metadata_decode_blob_size (pkey_ptr.178, &pkey_ptr);
              D.28937 = cols[4];
              D.28960 = D.28937 & 1;
              if (D.28960 != 0) goto <D.28961>; else goto <D.28962>;
              <D.28961>:
              D.28963 = mono_defaults.byte_class;
              D.28964 = mono_array_new (domain, D.28963, pkey_len);
              D.28965 = &aname->publicKey;
              mono_gc_wbarrier_set_field (aname, D.28965, D.28964);
              pkey_ptr.178 = pkey_ptr;
              D.28966 = aname->publicKey;
              D.28967 = mono_array_addr_with_size (D.28966, 1, 0);
              memcpy (D.28967, pkey_ptr.178, pkey_len);
              goto <D.28968>;
              <D.28962>:
              D.28963 = mono_defaults.byte_class;
              D.28969 = mono_array_new (domain, D.28963, pkey_len);
              D.28970 = &aname->keyToken;
              mono_gc_wbarrier_set_field (aname, D.28970, D.28969);
              pkey_ptr.178 = pkey_ptr;
              D.28971 = aname->keyToken;
              D.28972 = mono_array_addr_with_size (D.28971, 1, 0);
              memcpy (D.28972, pkey_ptr.178, pkey_len);
              <D.28968>:
            }
          finally
            {
              pkey_ptr = {CLOBBER};
            }
        }
        goto <D.28973>;
        <D.28957>:
        D.28963 = mono_defaults.byte_class;
        D.28974 = mono_array_new (domain, D.28963, 0);
        D.28970 = &aname->keyToken;
        mono_gc_wbarrier_set_field (aname, D.28970, D.28974);
        <D.28973>:
        {
          void * * __p;

          i.179 = (unsigned int) i;
          __p = mono_array_addr_with_size (result, 4, i.179);
          mono_gc_wbarrier_set_arrayref (result, __p, aname);
        }
      }
    finally
      {
        cols = {CLOBBER};
      }
  }
  i = i + 1;
  <D.22227>:
  if (i < count) goto <D.22226>; else goto <D.22228>;
  <D.22228>:
  D.28976 = result;
  return D.28976;
}


ves_icall_System_Reflection_Assembly_GetModulesInternal (struct MonoReflectionAssembly * assembly)
{
  struct MonoAssembly * D.28978;
  _Bool D.28979;
  long int D.28980;
  long int D.28981;
  unsigned char D.28984;
  _Bool D.28985;
  long int D.28986;
  long int D.28987;
  <unnamed-unsigned:24> D.28990;
  unsigned int i.180;
  unsigned int D.28992;
  struct MonoImage * * D.28993;
  struct MonoImage * D.28994;
  unsigned int i.181;
  struct MonoImage * D.28998;
  unsigned int file_count.182;
  unsigned int D.29000;
  unsigned int D.29001;
  struct MonoReflectionModule * D.29002;
  unsigned int j.183;
  struct MonoReflectionModule * D.29006;
  unsigned int D.29007;
  struct MonoReflectionModule * D.29010;
  int D.29012;
  unsigned int D.29015;
  const char * D.29016;
  struct MonoDomain * D.29017;
  struct MonoException * D.29018;
  struct MonoReflectionModule * D.29019;
  struct MonoArray * D.29020;
  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.28978 = assembly->assembly;
      image = D.28978->image;
      D.28979 = image == 0B;
      D.28980 = (long int) D.28979;
      D.28981 = __builtin_expect (D.28980, 0);
      if (D.28981 != 0) goto <D.28982>; else goto <D.28983>;
      <D.28982>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "icall.c", 4696, "image != NULL");
      <D.28983>:
      D.28978 = assembly->assembly;
      D.28984 = D.28978->dynamic;
      D.28985 = D.28984 != 0;
      D.28986 = (long int) D.28985;
      D.28987 = __builtin_expect (D.28986, 0);
      if (D.28987 != 0) goto <D.28988>; else goto <D.28989>;
      <D.28988>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "icall.c", 4697, "!assembly->assembly->dynamic");
      <D.28989>:
      table = &image->tables[38];
      D.28990 = table->rows;
      file_count = (int) D.28990;
      modules = image->modules;
      module_count = image->module_count;
      real_module_count = 0;
      i = 0;
      goto <D.22335>;
      <D.22334>:
      i.180 = (unsigned int) i;
      D.28992 = i.180 * 4;
      D.28993 = modules + D.28992;
      D.28994 = *D.28993;
      if (D.28994 != 0B) goto <D.28995>; else goto <D.28996>;
      <D.28995>:
      real_module_count = real_module_count + 1;
      <D.28996>:
      i = i + 1;
      <D.22335>:
      i.181 = (unsigned int) i;
      if (i.181 < module_count) goto <D.22334>; else goto <D.22336>;
      <D.22336>:
      D.28998 = mono_defaults.corlib;
      klass = mono_class_from_name (D.28998, "System.Reflection", "Module");
      file_count.182 = (unsigned int) file_count;
      D.29000 = real_module_count + file_count.182;
      D.29001 = D.29000 + 1;
      res = mono_array_new (domain, klass, D.29001);
      {
        void * * __p;

        __p = mono_array_addr_with_size (res, 4, 0);
        D.29002 = mono_module_get_object (domain, image);
        mono_gc_wbarrier_set_arrayref (res, __p, D.29002);
      }
      j = 1;
      i = 0;
      goto <D.22340>;
      <D.22339>:
      i.180 = (unsigned int) i;
      D.28992 = i.180 * 4;
      D.28993 = modules + D.28992;
      D.28994 = *D.28993;
      if (D.28994 != 0B) goto <D.29003>; else goto <D.29004>;
      <D.29003>:
      {
        void * * __p;

        j.183 = (unsigned int) j;
        __p = mono_array_addr_with_size (res, 4, j.183);
        i.180 = (unsigned int) i;
        D.28992 = i.180 * 4;
        D.28993 = modules + D.28992;
        D.28994 = *D.28993;
        D.29006 = mono_module_get_object (domain, D.28994);
        mono_gc_wbarrier_set_arrayref (res, __p, D.29006);
      }
      j = j + 1;
      <D.29004>:
      i = i + 1;
      <D.22340>:
      i.181 = (unsigned int) i;
      if (i.181 < module_count) goto <D.22339>; else goto <D.22341>;
      <D.22341>:
      i = 0;
      goto <D.22347>;
      <D.22346>:
      mono_metadata_decode_row (table, i, &cols, 3);
      D.29007 = cols[0];
      if (D.29007 != 0) goto <D.29008>; else goto <D.29009>;
      <D.29008>:
      {
        void * * __p;

        j.183 = (unsigned int) j;
        __p = mono_array_addr_with_size (res, 4, j.183);
        D.29010 = mono_module_file_get_object (domain, image, i);
        mono_gc_wbarrier_set_arrayref (res, __p, D.29010);
      }
      goto <D.29011>;
      <D.29009>:
      {
        struct MonoImage * m;

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

          D.29015 = cols[1];
          D.29016 = mono_metadata_string_heap (image, D.29015);
          D.29017 = mono_domain_get ();
          fname = mono_string_new (D.29017, D.29016);
          D.29018 = mono_get_exception_file_not_found2 (0B, fname);
          mono_raise_exception (D.29018);
        }
        <D.29014>:
        {
          void * * __p;

          j.183 = (unsigned int) j;
          __p = mono_array_addr_with_size (res, 4, j.183);
          D.29019 = mono_module_get_object (domain, m);
          mono_gc_wbarrier_set_arrayref (res, __p, D.29019);
        }
      }
      <D.29011>:
      i = i + 1;
      j = j + 1;
      <D.22347>:
      if (i < file_count) goto <D.22346>; else goto <D.22348>;
      <D.22348>:
      D.29020 = res;
      return D.29020;
    }
  finally
    {
      cols = {CLOBBER};
    }
}


ves_icall_System_Reflection_Assembly_GetManifestResourceNames (struct MonoReflectionAssembly * assembly)
{
  struct MonoAssembly * D.29023;
  struct MonoImage * D.29024;
  <unnamed-unsigned:24> D.29025;
  unsigned int D.29026;
  struct MonoClass * D.29027;
  struct MonoVTable * D.29028;
  struct MonoDomain * D.29029;
  unsigned int D.29030;
  unsigned int i.184;
  struct MonoString * D.29032;
  int D.29033;
  struct MonoArray * D.29034;
  struct MonoTableInfo * table;
  struct MonoArray * result;
  int i;
  const char * val;

  D.29023 = assembly->assembly;
  D.29024 = D.29023->image;
  table = &D.29024->tables[40];
  D.29025 = table->rows;
  D.29026 = (unsigned int) D.29025;
  D.29027 = mono_defaults.string_class;
  D.29028 = MEM[(struct MonoObject *)assembly].vtable;
  D.29029 = D.29028->domain;
  result = mono_array_new (D.29029, D.29027, D.29026);
  i = 0;
  goto <D.22193>;
  <D.22192>:
  D.29030 = mono_metadata_decode_row_col (table, i, 2);
  D.29023 = assembly->assembly;
  D.29024 = D.29023->image;
  val = mono_metadata_string_heap (D.29024, D.29030);
  {
    void * * __p;

    i.184 = (unsigned int) i;
    __p = mono_array_addr_with_size (result, 4, i.184);
    D.29028 = MEM[(struct MonoObject *)assembly].vtable;
    D.29029 = D.29028->domain;
    D.29032 = mono_string_new (D.29029, val);
    mono_gc_wbarrier_set_arrayref (result, __p, D.29032);
  }
  i = i + 1;
  <D.22193>:
  D.29025 = table->rows;
  D.29033 = (int) D.29025;
  if (D.29033 > i) goto <D.22192>; else goto <D.22194>;
  <D.22194>:
  D.29034 = result;
  return D.29034;
}


ves_icall_System_Reflection_Assembly_GetManifestResourceInternal (struct MonoReflectionAssembly * assembly, struct MonoString * name, gint32 * size, struct MonoReflectionModule * * ref_module)
{
  struct MonoAssembly * D.29036;
  struct MonoImage * D.29037;
  int i.185;
  unsigned int D.29039;
  int D.22255;
  <unnamed-unsigned:24> D.29041;
  unsigned int D.29042;
  void * D.29045;
  unsigned int D.29048;
  _Bool D.29049;
  long int D.29050;
  long int D.29051;
  int file_idx.186;
  struct MonoDomain * D.29058;
  struct MonoReflectionModule * D.29059;
  unsigned int D.29060;
  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.29036 = assembly->assembly;
      D.29037 = D.29036->image;
      table = &D.29037->tables[40];
      i = 0;
      goto <D.22258>;
      <D.22257>:
      i.185 = (int) i;
      mono_metadata_decode_row (table, i.185, &cols, 4);
      D.29039 = cols[2];
      D.29036 = assembly->assembly;
      D.29037 = D.29036->image;
      val = mono_metadata_string_heap (D.29037, D.29039);
      {
        size_t __s1_len;
        size_t __s2_len;

        D.22255 = __builtin_strcmp (val, n);
      }
      if (D.22255 == 0) goto <D.22256>; else goto <D.29040>;
      <D.29040>:
      i = i + 1;
      <D.22258>:
      D.29041 = table->rows;
      D.29042 = (unsigned int) D.29041;
      if (D.29042 > i) goto <D.22257>; else goto <D.22256>;
      <D.22256>:
      monoeg_g_free (n);
      D.29041 = table->rows;
      D.29042 = (unsigned int) D.29041;
      if (D.29042 == i) goto <D.29043>; else goto <D.29044>;
      <D.29043>:
      D.29045 = 0B;
      return D.29045;
      <D.29044>:
      impl = cols[3];
      if (impl != 0) goto <D.29046>; else goto <D.29047>;
      <D.29046>:
      D.29048 = impl & 3;
      D.29049 = D.29048 != 0;
      D.29050 = (long int) D.29049;
      D.29051 = __builtin_expect (D.29050, 0);
      if (D.29051 != 0) goto <D.29052>; else goto <D.29053>;
      <D.29052>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "icall.c", 4553, "(impl & MONO_IMPLEMENTATION_MASK) == MONO_IMPLEMENTATION_FILE");
      <D.29053>:
      file_idx = impl >> 2;
      file_idx.186 = (int) file_idx;
      D.29036 = assembly->assembly;
      D.29037 = D.29036->image;
      module = mono_image_load_file_for_image (D.29037, file_idx.186);
      if (module == 0B) goto <D.29055>; else goto <D.29056>;
      <D.29055>:
      D.29045 = 0B;
      return D.29045;
      <D.29056>:
      goto <D.29057>;
      <D.29047>:
      D.29036 = assembly->assembly;
      module = D.29036->image;
      <D.29057>:
      D.29058 = mono_domain_get ();
      D.29059 = mono_module_get_object (D.29058, module);
      mono_gc_wbarrier_generic_store (ref_module, D.29059);
      D.29060 = cols[0];
      D.29045 = mono_image_get_resource (module, D.29060, size);
      return D.29045;
    }
  finally
    {
      cols = {CLOBBER};
    }
}


ves_icall_System_Reflection_Assembly_GetManifestResourceInfoInternal (struct MonoReflectionAssembly * assembly, struct MonoString * name, struct MonoManifestResourceInfo * info)
{
  struct MonoAssembly * D.29063;
  struct MonoImage * D.29064;
  unsigned int D.29065;
  int D.22278;
  <unnamed-unsigned:24> D.29067;
  int D.29068;
  gboolean D.29071;
  unsigned int D.29072;
  unsigned int D.29076;
  unsigned int D.29077;
  int D.29078;
  unsigned int D.29079;
  struct MonoVTable * D.29080;
  struct MonoDomain * D.29081;
  struct MonoString * D.29082;
  struct MonoString * * D.29083;
  unsigned int D.29084;
  struct MonoAssembly * * D.29088;
  sizetype i.187;
  sizetype D.29090;
  sizetype D.29091;
  struct MonoAssembly * * D.29092;
  struct MonoAssembly * D.29093;
  char * D.29096;
  struct MonoDomain * D.29097;
  struct MonoReflectionAssembly * D.29098;
  struct MonoReflectionAssembly * * D.29099;
  struct MonoReflectionAssembly * D.29100;
  unsigned int D.29101;
  unsigned int D.29102;
  struct MonoTableInfo * table;
  int i;
  guint32 cols[4];
  guint32 file_cols[3];
  const char * val;
  char * n;

  try
    {
      D.29063 = assembly->assembly;
      D.29064 = D.29063->image;
      table = &D.29064->tables[40];
      n = mono_string_to_utf8 (name);
      i = 0;
      goto <D.22281>;
      <D.22280>:
      mono_metadata_decode_row (table, i, &cols, 4);
      D.29065 = cols[2];
      D.29063 = assembly->assembly;
      D.29064 = D.29063->image;
      val = mono_metadata_string_heap (D.29064, D.29065);
      {
        size_t __s1_len;
        size_t __s2_len;

        D.22278 = __builtin_strcmp (val, n);
      }
      if (D.22278 == 0) goto <D.22279>; else goto <D.29066>;
      <D.29066>:
      i = i + 1;
      <D.22281>:
      D.29067 = table->rows;
      D.29068 = (int) D.29067;
      if (D.29068 > i) goto <D.22280>; else goto <D.22279>;
      <D.22279>:
      monoeg_g_free (n);
      D.29067 = table->rows;
      D.29068 = (int) D.29067;
      if (D.29068 == i) goto <D.29069>; else goto <D.29070>;
      <D.29069>:
      D.29071 = 0;
      return D.29071;
      <D.29070>:
      D.29072 = cols[3];
      if (D.29072 == 0) goto <D.29073>; else goto <D.29074>;
      <D.29073>:
      info->location = 5;
      goto <D.29075>;
      <D.29074>:
      D.29072 = cols[3];
      D.29076 = D.29072 & 3;
      switch (D.29076) <default: <D.29103>, case 0: <D.22282>, case 1: <D.22284>, case 2: <D.22287>>
      <D.22282>:
      D.29072 = cols[3];
      D.29077 = D.29072 >> 2;
      i = (int) D.29077;
      D.29063 = assembly->assembly;
      D.29064 = D.29063->image;
      table = &D.29064->tables[38];
      D.29078 = i + -1;
      mono_metadata_decode_row (table, D.29078, &file_cols, 3);
      D.29079 = file_cols[1];
      D.29063 = assembly->assembly;
      D.29064 = D.29063->image;
      val = mono_metadata_string_heap (D.29064, D.29079);
      D.29080 = MEM[(struct MonoObject *)assembly].vtable;
      D.29081 = D.29080->domain;
      D.29082 = mono_string_new (D.29081, val);
      D.29083 = &info->filename;
      mono_gc_wbarrier_set_field (info, D.29083, D.29082);
      D.29084 = file_cols[0];
      if (D.29084 != 0) goto <D.29085>; else goto <D.29086>;
      <D.29085>:
      info->location = 0;
      goto <D.29087>;
      <D.29086>:
      info->location = 1;
      <D.29087>:
      goto <D.22283>;
      <D.22284>:
      D.29072 = cols[3];
      D.29077 = D.29072 >> 2;
      i = (int) D.29077;
      D.29078 = i + -1;
      D.29063 = assembly->assembly;
      D.29064 = D.29063->image;
      mono_assembly_load_reference (D.29064, D.29078);
      D.29063 = assembly->assembly;
      D.29064 = D.29063->image;
      D.29088 = D.29064->references;
      i.187 = (sizetype) i;
      D.29090 = i.187 + 1073741823;
      D.29091 = D.29090 * 4;
      D.29092 = D.29088 + D.29091;
      D.29093 = *D.29092;
      if (D.29093 == 4294967295B) goto <D.29094>; else goto <D.29095>;
      <D.29094>:
      {
        char * msg;
        struct MonoException * ex;

        D.29063 = assembly->assembly;
        D.29064 = D.29063->image;
        D.29096 = D.29064->name;
        D.29078 = i + -1;
        msg = monoeg_g_strdup_printf ("Assembly %d referenced from assembly %s not found ", D.29078, D.29096);
        ex = mono_get_exception_file_not_found2 (msg, 0B);
        monoeg_g_free (msg);
        mono_raise_exception (ex);
      }
      <D.29095>:
      D.29063 = assembly->assembly;
      D.29064 = D.29063->image;
      D.29088 = D.29064->references;
      i.187 = (sizetype) i;
      D.29090 = i.187 + 1073741823;
      D.29091 = D.29090 * 4;
      D.29092 = D.29088 + D.29091;
      D.29093 = *D.29092;
      D.29097 = mono_domain_get ();
      D.29098 = mono_assembly_get_object (D.29097, D.29093);
      D.29099 = &info->assembly;
      mono_gc_wbarrier_set_field (info, D.29099, D.29098);
      D.29100 = info->assembly;
      ves_icall_System_Reflection_Assembly_GetManifestResourceInfoInternal (D.29100, name, info);
      D.29101 = info->location;
      D.29102 = D.29101 | 2;
      info->location = D.29102;
      goto <D.22283>;
      <D.22287>:
      monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "icall.c", 4625);
      <D.29103>:
      <D.22283>:
      <D.29075>:
      D.29071 = 1;
      return D.29071;
    }
  finally
    {
      cols = {CLOBBER};
      file_cols = {CLOBBER};
    }
}


ves_icall_System_Reflection_Assembly_GetManifestModuleInternal (struct MonoReflectionAssembly * assembly)
{
  struct MonoReflectionModule * D.29106;
  struct MonoAssembly * D.29107;
  struct MonoImage * D.29108;
  struct MonoVTable * D.29109;
  struct MonoDomain * D.29110;

  D.29107 = assembly->assembly;
  D.29108 = D.29107->image;
  D.29109 = MEM[(struct MonoObject *)assembly].vtable;
  D.29110 = D.29109->domain;
  D.29106 = mono_module_get_object (D.29110, D.29108);
  return D.29106;
}


ves_icall_System_Reflection_Assembly_GetFilesInternal (struct MonoReflectionAssembly * assembly, struct MonoString * name, MonoBoolean resource_modules)
{
  struct MonoAssembly * D.29112;
  struct MonoImage * D.29113;
  unsigned int D.29116;
  int D.22307;
  char * D.29119;
  struct MonoVTable * D.29120;
  struct MonoDomain * D.29121;
  struct MonoObject * D.29122;
  <unnamed-unsigned:24> D.29123;
  int D.29124;
  unsigned int D.29128;
  unsigned int D.29129;
  unsigned int count.188;
  struct MonoClass * D.29131;
  unsigned int D.29135;
  unsigned int D.29136;
  unsigned int D.29137;
  struct MonoString * D.29138;
  struct MonoTableInfo * table;
  struct MonoArray * result;
  int i;
  int count;
  const char * val;
  char * n;

  D.29112 = assembly->assembly;
  D.29113 = D.29112->image;
  table = &D.29113->tables[38];
  result = 0B;
  if (name != 0B) goto <D.29114>; else goto <D.29115>;
  <D.29114>:
  n = mono_string_to_utf8 (name);
  i = 0;
  goto <D.22310>;
  <D.22309>:
  D.29116 = mono_metadata_decode_row_col (table, i, 1);
  D.29112 = assembly->assembly;
  D.29113 = D.29112->image;
  val = mono_metadata_string_heap (D.29113, D.29116);
  {
    size_t __s1_len;
    size_t __s2_len;

    D.22307 = __builtin_strcmp (val, n);
  }
  if (D.22307 == 0) goto <D.29117>; else goto <D.29118>;
  <D.29117>:
  {
    struct MonoString * fn;

    monoeg_g_free (n);
    D.29112 = assembly->assembly;
    D.29119 = D.29112->basedir;
    n = g_concat_dir_and_file (D.29119, val);
    D.29120 = MEM[(struct MonoObject *)assembly].vtable;
    D.29121 = D.29120->domain;
    fn = mono_string_new (D.29121, n);
    monoeg_g_free (n);
    D.29122 = fn;
    return D.29122;
  }
  <D.29118>:
  i = i + 1;
  <D.22310>:
  D.29123 = table->rows;
  D.29124 = (int) D.29123;
  if (D.29124 > i) goto <D.22309>; else goto <D.22311>;
  <D.22311>:
  monoeg_g_free (n);
  D.29122 = 0B;
  return D.29122;
  <D.29115>:
  count = 0;
  i = 0;
  goto <D.22313>;
  <D.22312>:
  if (resource_modules != 0) goto <D.29125>; else goto <D.29127>;
  <D.29127>:
  D.29128 = mono_metadata_decode_row_col (table, i, 0);
  D.29129 = D.29128 & 1;
  if (D.29129 == 0) goto <D.29125>; else goto <D.29126>;
  <D.29125>:
  count = count + 1;
  <D.29126>:
  i = i + 1;
  <D.22313>:
  D.29123 = table->rows;
  D.29124 = (int) D.29123;
  if (D.29124 > i) goto <D.22312>; else goto <D.22314>;
  <D.22314>:
  count.188 = (unsigned int) count;
  D.29131 = mono_defaults.string_class;
  D.29120 = MEM[(struct MonoObject *)assembly].vtable;
  D.29121 = D.29120->domain;
  result = mono_array_new (D.29121, D.29131, count.188);
  count = 0;
  i = 0;
  goto <D.22317>;
  <D.22316>:
  if (resource_modules != 0) goto <D.29132>; else goto <D.29134>;
  <D.29134>:
  D.29135 = mono_metadata_decode_row_col (table, i, 0);
  D.29136 = D.29135 & 1;
  if (D.29136 == 0) goto <D.29132>; else goto <D.29133>;
  <D.29132>:
  D.29137 = mono_metadata_decode_row_col (table, i, 1);
  D.29112 = assembly->assembly;
  D.29113 = D.29112->image;
  val = mono_metadata_string_heap (D.29113, D.29137);
  D.29112 = assembly->assembly;
  D.29119 = D.29112->basedir;
  n = g_concat_dir_and_file (D.29119, val);
  {
    void * * __p;

    count.188 = (unsigned int) count;
    __p = mono_array_addr_with_size (result, 4, count.188);
    D.29120 = MEM[(struct MonoObject *)assembly].vtable;
    D.29121 = D.29120->domain;
    D.29138 = mono_string_new (D.29121, n);
    mono_gc_wbarrier_set_arrayref (result, __p, D.29138);
  }
  monoeg_g_free (n);
  count = count + 1;
  <D.29133>:
  i = i + 1;
  <D.22317>:
  D.29123 = table->rows;
  D.29124 = (int) D.29123;
  if (D.29124 > i) goto <D.22316>; else goto <D.22318>;
  <D.22318>:
  D.29122 = result;
  return D.29122;
}


g_concat_dir_and_file (const char * dir, const char * file)
{
  char * D.29142;
  unsigned int D.29145;
  sizetype D.29146;
  const char * D.29147;
  char D.29148;

  if (dir == 0B) goto <D.29140>; else goto <D.29141>;
  <D.29140>:
  monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "icall.c", 4511, "dir != NULL");
  D.29142 = 0B;
  return D.29142;
  <D.29141>:
  if (file == 0B) goto <D.29143>; else goto <D.29144>;
  <D.29143>:
  monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "icall.c", 4512, "file != NULL");
  D.29142 = 0B;
  return D.29142;
  <D.29144>:
  D.29145 = strlen (dir);
  D.29146 = D.29145 + 4294967295;
  D.29147 = dir + D.29146;
  D.29148 = *D.29147;
  if (D.29148 != 47) goto <D.29149>; else goto <D.29150>;
  <D.29149>:
  D.29142 = monoeg_g_strconcat (dir, "/", file, 0B);
  return D.29142;
  <D.29150>:
  D.29142 = monoeg_g_strconcat (dir, file, 0B);
  return D.29142;
}


ves_icall_System_Reflection_Assembly_GetExecutingAssembly ()
{
  struct MonoMethod * dest.189;
  _Bool D.29153;
  long int D.29154;
  long int D.29155;
  struct MonoReflectionAssembly * D.29158;
  struct MonoClass * D.29159;
  struct MonoImage * D.29160;
  struct MonoAssembly * D.29161;
  struct MonoDomain * D.29162;
  struct MonoMethod * dest;

  try
    {
      dest = 0B;
      mono_stack_walk_no_il (get_executing, &dest);
      dest.189 = dest;
      D.29153 = dest.189 == 0B;
      D.29154 = (long int) D.29153;
      D.29155 = __builtin_expect (D.29154, 0);
      if (D.29155 != 0) goto <D.29156>; else goto <D.29157>;
      <D.29156>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "icall.c", 4821, "dest");
      <D.29157>:
      dest.189 = dest;
      D.29159 = dest.189->klass;
      D.29160 = D.29159->image;
      D.29161 = D.29160->assembly;
      D.29162 = mono_domain_get ();
      D.29158 = mono_assembly_get_object (D.29162, D.29161);
      return D.29158;
    }
  finally
    {
      dest = {CLOBBER};
    }
}


get_executing (struct MonoMethod * m, gint32 no, gint32 ilo, gboolean managed, void * data)
{
  gboolean D.29167;
  struct MonoMethod * D.29168;
  int D.20848;
  int iftmp.190;
  int D.20847;
  struct MonoClass * D.29174;
  const char[18] * D.29175;
  unsigned char D.29176;
  int D.29177;
  unsigned char D.29178;
  int D.29179;
  _Bool D.29180;
  _Bool D.29181;
  _Bool D.29182;
  const unsigned char * D.29185;
  unsigned char D.29186;
  int D.29187;
  const unsigned char * D.29188;
  unsigned char D.29189;
  int D.29190;
  _Bool D.29191;
  _Bool D.29192;
  const unsigned char * D.29195;
  unsigned char D.29196;
  int D.29197;
  const unsigned char * D.29198;
  unsigned char D.29199;
  int D.29200;
  _Bool D.29201;
  _Bool D.29202;
  const unsigned char * D.29205;
  unsigned char D.29206;
  int D.29207;
  const unsigned char * D.29208;
  unsigned char D.29209;
  int D.29210;
  const char * D.29212;
  struct MonoMethod * * dest;

  dest = data;
  if (managed == 0) goto <D.29165>; else goto <D.29166>;
  <D.29165>:
  D.29167 = 0;
  return D.29167;
  <D.29166>:
  D.29168 = *dest;
  if (D.29168 == 0B) goto <D.29169>; else goto <D.29170>;
  <D.29169>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      D.29174 = m->klass;
      __s2 = D.29174->name_space;
      D.29175 = "System.Reflection";
      D.29176 = MEM[(const unsigned char *)D.29175];
      D.29177 = (int) D.29176;
      D.29178 = *__s2;
      D.29179 = (int) D.29178;
      __result = D.29177 - D.29179;
      {
        D.29180 = __s2_len != 0;
        D.29181 = __result == 0;
        D.29182 = D.29180 & D.29181;
        if (D.29182 != 0) goto <D.29183>; else goto <D.29184>;
        <D.29183>:
        D.29185 = &MEM[(void *)"System.Reflection" + 1B];
        D.29186 = *D.29185;
        D.29187 = (int) D.29186;
        D.29188 = __s2 + 1;
        D.29189 = *D.29188;
        D.29190 = (int) D.29189;
        __result = D.29187 - D.29190;
        D.29191 = __s2_len > 1;
        D.29181 = __result == 0;
        D.29192 = D.29191 & D.29181;
        if (D.29192 != 0) goto <D.29193>; else goto <D.29194>;
        <D.29193>:
        D.29195 = &MEM[(void *)"System.Reflection" + 2B];
        D.29196 = *D.29195;
        D.29197 = (int) D.29196;
        D.29198 = __s2 + 2;
        D.29199 = *D.29198;
        D.29200 = (int) D.29199;
        __result = D.29197 - D.29200;
        D.29201 = __s2_len > 2;
        D.29181 = __result == 0;
        D.29202 = D.29201 & D.29181;
        if (D.29202 != 0) goto <D.29203>; else goto <D.29204>;
        <D.29203>:
        D.29205 = &MEM[(void *)"System.Reflection" + 3B];
        D.29206 = *D.29205;
        D.29207 = (int) D.29206;
        D.29208 = __s2 + 3;
        D.29209 = *D.29208;
        D.29210 = (int) D.29209;
        __result = D.29207 - D.29210;
        <D.29204>:
        <D.29194>:
        <D.29184>:
      }
      D.20847 = __result;
    }
    iftmp.190 = -D.20847;
    goto <D.29211>;
    <D.29173>:
    D.29174 = m->klass;
    D.29212 = D.29174->name_space;
    iftmp.190 = __builtin_strcmp (D.29212, "System.Reflection");
    <D.29211>:
    D.20848 = iftmp.190;
  }
  if (D.20848 == 0) goto <D.29213>; else goto <D.29214>;
  <D.29213>:
  D.29167 = 0;
  return D.29167;
  <D.29214>:
  *dest = m;
  D.29167 = 1;
  return D.29167;
  <D.29170>:
  D.29167 = 0;
  return D.29167;
}


ves_icall_System_Reflection_Assembly_GetEntryAssembly ()
{
  struct MonoAssembly * D.29216;
  struct MonoReflectionAssembly * D.29219;
  struct MonoDomain * domain;

  domain = mono_domain_get ();
  D.29216 = domain->entry_assembly;
  if (D.29216 == 0B) goto <D.29217>; else goto <D.29218>;
  <D.29217>:
  D.29219 = 0B;
  return D.29219;
  <D.29218>:
  D.29216 = domain->entry_assembly;
  D.29219 = mono_assembly_get_object (domain, D.29216);
  return D.29219;
}


ves_icall_System_Reflection_Assembly_GetCallingAssembly ()
{
  struct MonoMethod * dest.191;
  struct MonoReflectionAssembly * D.29224;
  struct MonoClass * D.29225;
  struct MonoImage * D.29226;
  struct MonoAssembly * D.29227;
  struct MonoDomain * D.29228;
  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.191 = dest;
      if (dest.191 == 0B) goto <D.29222>; else goto <D.29223>;
      <D.29222>:
      dest = m;
      <D.29223>:
      dest.191 = dest;
      D.29225 = dest.191->klass;
      D.29226 = D.29225->image;
      D.29227 = D.29226->assembly;
      D.29228 = mono_domain_get ();
      D.29224 = mono_assembly_get_object (D.29228, D.29227);
      return D.29224;
    }
  finally
    {
      dest = {CLOBBER};
    }
}


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

  dest = data;
  if (managed == 0) goto <D.29231>; else goto <D.29232>;
  <D.29231>:
  D.29233 = 0;
  return D.29233;
  <D.29232>:
  D.29234 = *dest;
  if (D.29234 == m) goto <D.29235>; else goto <D.29236>;
  <D.29235>:
  *dest = 0B;
  D.29233 = 0;
  return D.29233;
  <D.29236>:
  D.29234 = *dest;
  if (D.29234 == 0B) goto <D.29237>; else goto <D.29238>;
  <D.29237>:
  *dest = m;
  D.29233 = 1;
  return D.29233;
  <D.29238>:
  D.29233 = 0;
  return D.29233;
}


ves_icall_System_Reflection_Assembly_FillName (struct MonoReflectionAssembly * assembly, struct MonoReflectionAssemblyName * aname)
{
  struct MonoImage * D.29240;
  char * D.29241;
  int D.29242;
  struct MonoAssemblyName * D.29245;
  struct MonoVTable * D.29246;
  struct MonoDomain * D.29247;
  char * D.29248;
  gchar * absolute;
  struct MonoAssembly * mass;

  mass = assembly->assembly;
  D.29240 = mass->image;
  D.29241 = D.29240->name;
  D.29242 = monoeg_g_path_is_absolute (D.29241);
  if (D.29242 != 0) goto <D.29243>; else goto <D.29244>;
  <D.29243>:
  D.29240 = mass->image;
  D.29241 = D.29240->name;
  D.29245 = &mass->aname;
  D.29246 = MEM[(struct MonoObject *)assembly].vtable;
  D.29247 = D.29246->domain;
  fill_reflection_assembly_name (D.29247, aname, D.29245, D.29241, 1, 1, 1);
  return;
  <D.29244>:
  D.29240 = mass->image;
  D.29241 = D.29240->name;
  D.29248 = mass->basedir;
  absolute = monoeg_g_build_path ("/", D.29248, D.29241, 0B);
  D.29245 = &mass->aname;
  D.29246 = MEM[(struct MonoObject *)assembly].vtable;
  D.29247 = D.29246->domain;
  fill_reflection_assembly_name (D.29247, aname, D.29245, absolute, 1, 1, 1);
  monoeg_g_free (absolute);
}


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

  D.29250 = this;
  return D.29250;
}


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

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


ves_icall_System_Object_GetType (struct MonoObject * obj)
{
  struct MonoVTable * D.29254;
  struct MonoClass * D.29255;
  struct MonoClass * D.29256;
  struct MonoReflectionType * D.29259;
  struct MonoRemoteClass * D.29260;
  struct MonoClass * D.29261;
  struct MonoType * D.29262;
  struct MonoDomain * D.29263;
  struct MonoType * D.29264;

  D.29254 = obj->vtable;
  D.29255 = D.29254->klass;
  D.29256 = mono_defaults.transparent_proxy_class;
  if (D.29255 == D.29256) goto <D.29257>; else goto <D.29258>;
  <D.29257>:
  D.29260 = MEM[(struct MonoTransparentProxy *)obj].remote_class;
  D.29261 = D.29260->proxy_class;
  D.29262 = &D.29261->byval_arg;
  D.29254 = obj->vtable;
  D.29263 = D.29254->domain;
  D.29259 = mono_type_get_object (D.29263, D.29262);
  return D.29259;
  <D.29258>:
  D.29254 = obj->vtable;
  D.29255 = D.29254->klass;
  D.29264 = &D.29255->byval_arg;
  D.29254 = obj->vtable;
  D.29263 = D.29254->domain;
  D.29259 = mono_type_get_object (D.29263, D.29264);
  return D.29259;
}


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.29266;
  struct MonoClass * D.29267;
  struct MonoType * D.29268;
  struct MonoType * D.29269;
  unsigned char D.29270;
  _Bool D.29271;
  long int D.29272;
  long int D.29273;

  D.29266 = obj->vtable;
  D.29267 = D.29266->klass;
  D.29268 = &D.29267->byval_arg;
  mtype->type = D.29268;
  D.29269 = mtype->type;
  D.29270 = D.29269->type;
  D.29271 = D.29270 == 0;
  D.29272 = (long int) D.29271;
  D.29273 = __builtin_expect (D.29272, 0);
  if (D.29273 != 0) goto <D.29274>; else goto <D.29275>;
  <D.29274>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "icall.c", 1149, "mtype->type->type");
  <D.29275>:
}


vell_icall_MonoType_get_core_clr_security_level (struct MonoReflectionType * this)
{
  struct MonoType * D.29276;
  int D.29277;
  <unnamed type> D.29278;
  struct MonoClass * klass;

  D.29276 = this->type;
  klass = mono_class_from_mono_type (D.29276);
  mono_class_init_or_throw (klass);
  D.29278 = mono_security_core_clr_class_level (klass);
  D.29277 = (int) D.29278;
  return D.29277;
}


ves_icall_get_attributes (struct MonoReflectionType * type)
{
  struct MonoType * D.29280;
  guint32 D.29281;
  struct MonoClass * klass;

  D.29280 = type->type;
  klass = mono_class_from_mono_type (D.29280);
  D.29281 = klass->flags;
  return D.29281;
}


ves_icall_MonoType_get_Namespace (struct MonoReflectionType * type)
{
  struct MonoType * D.29283;
  struct MonoClass * D.29284;
  const char * D.29285;
  char D.29286;
  struct MonoString * D.29289;
  struct MonoDomain * domain;
  struct MonoClass * class;

  domain = mono_domain_get ();
  D.29283 = type->type;
  class = mono_class_from_mono_type (D.29283);
  goto <D.21318>;
  <D.21317>:
  class = class->nested_in;
  <D.21318>:
  D.29284 = class->nested_in;
  if (D.29284 != 0B) goto <D.21317>; else goto <D.21319>;
  <D.21319>:
  D.29285 = class->name_space;
  D.29286 = *D.29285;
  if (D.29286 == 0) goto <D.29287>; else goto <D.29288>;
  <D.29287>:
  D.29289 = 0B;
  return D.29289;
  <D.29288>:
  D.29285 = class->name_space;
  D.29289 = mono_string_new (domain, D.29285);
  return D.29289;
}


ves_icall_MonoType_get_Name (struct MonoReflectionType * type)
{
  struct MonoType * D.29291;
  unsigned char D.29292;
  unsigned char D.29293;
  const char * D.29296;
  struct MonoString * D.29297;
  struct MonoDomain * domain;
  struct MonoClass * class;

  domain = mono_domain_get ();
  D.29291 = type->type;
  class = mono_class_from_mono_type (D.29291);
  D.29291 = type->type;
  D.29292 = BIT_FIELD_REF <*D.29291, 8, 56>;
  D.29293 = D.29292 & 64;
  if (D.29293 != 0) goto <D.29294>; else goto <D.29295>;
  <D.29294>:
  {
    char * n;
    struct MonoString * res;

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


ves_icall_MonoType_get_Module (struct MonoReflectionType * type)
{
  struct MonoType * D.29299;
  struct MonoReflectionModule * D.29300;
  struct MonoImage * D.29301;
  struct MonoVTable * D.29302;
  struct MonoDomain * D.29303;
  struct MonoClass * class;

  D.29299 = type->type;
  class = mono_class_from_mono_type (D.29299);
  D.29301 = class->image;
  D.29302 = MEM[(struct MonoObject *)type].vtable;
  D.29303 = D.29302->domain;
  D.29300 = mono_module_get_object (D.29303, D.29301);
  return D.29300;
}


ves_icall_MonoType_get_IsGenericParameter (struct MonoReflectionType * type)
{
  MonoBoolean D.29305;
  struct MonoType * D.29306;

  D.29306 = type->type;
  D.29305 = is_generic_parameter (D.29306);
  return D.29305;
}


ves_icall_MonoType_get_DeclaringType (struct MonoReflectionType * type)
{
  struct MonoType * D.29308;
  unsigned char D.29309;
  unsigned char D.29310;
  struct MonoReflectionType * D.29313;
  unsigned char D.29314;
  struct MonoGenericParam * D.29317;
  struct MonoGenericContainer * D.29318;
  struct MonoMethod * D.29322;
  struct MonoClass * D.29324;
  struct MonoReflectionType * iftmp.192;
  struct MonoType * D.29328;
  struct MonoDomain * domain;
  struct MonoClass * class;

  domain = mono_domain_get ();
  D.29308 = type->type;
  D.29309 = BIT_FIELD_REF <*D.29308, 8, 56>;
  D.29310 = D.29309 & 64;
  if (D.29310 != 0) goto <D.29311>; else goto <D.29312>;
  <D.29311>:
  D.29313 = 0B;
  return D.29313;
  <D.29312>:
  D.29308 = type->type;
  D.29314 = D.29308->type;
  if (D.29314 == 19) goto <D.29315>; else goto <D.29316>;
  <D.29315>:
  D.29308 = type->type;
  D.29317 = D.29308->data.generic_param;
  D.29318 = D.29317->owner;
  class = D.29318->owner.klass;
  goto <D.29319>;
  <D.29316>:
  D.29308 = type->type;
  D.29314 = D.29308->type;
  if (D.29314 == 30) goto <D.29320>; else goto <D.29321>;
  <D.29320>:
  D.29308 = type->type;
  D.29317 = D.29308->data.generic_param;
  D.29318 = D.29317->owner;
  D.29322 = D.29318->owner.method;
  class = D.29322->klass;
  goto <D.29323>;
  <D.29321>:
  D.29308 = type->type;
  D.29324 = mono_class_from_mono_type (D.29308);
  class = D.29324->nested_in;
  <D.29323>:
  <D.29319>:
  if (class != 0B) goto <D.29326>; else goto <D.29327>;
  <D.29326>:
  D.29328 = &class->byval_arg;
  iftmp.192 = mono_type_get_object (domain, D.29328);
  goto <D.29329>;
  <D.29327>:
  iftmp.192 = 0B;
  <D.29329>:
  D.29313 = iftmp.192;
  return D.29313;
}


ves_icall_MonoType_get_DeclaringMethod (struct MonoReflectionType * ref_type)
{
  unsigned char D.29333;
  unsigned char D.29334;
  unsigned char D.29336;
  _Bool D.29337;
  _Bool D.29338;
  _Bool D.29339;
  struct MonoException * D.29340;
  unsigned char D.29341;
  struct MonoReflectionMethod * D.29344;
  struct MonoGenericParam * D.29345;
  struct MonoGenericContainer * D.29346;
  _Bool D.29347;
  long int D.29348;
  long int D.29349;
  struct MonoClass * D.29352;
  struct MonoVTable * D.29353;
  struct MonoDomain * D.29354;
  struct MonoMethod * method;
  struct MonoType * type;

  type = ref_type->type;
  D.29333 = BIT_FIELD_REF <*type, 8, 56>;
  D.29334 = D.29333 & 64;
  if (D.29334 != 0) goto <D.29331>; else goto <D.29335>;
  <D.29335>:
  D.29336 = type->type;
  D.29337 = D.29336 != 30;
  D.29338 = D.29336 != 19;
  D.29339 = D.29337 & D.29338;
  if (D.29339 != 0) goto <D.29331>; else goto <D.29332>;
  <D.29331>:
  D.29340 = mono_get_exception_invalid_operation ("DeclaringMethod can only be used on generic arguments");
  mono_raise_exception (D.29340);
  <D.29332>:
  D.29341 = type->type;
  if (D.29341 == 19) goto <D.29342>; else goto <D.29343>;
  <D.29342>:
  D.29344 = 0B;
  return D.29344;
  <D.29343>:
  D.29345 = type->data.generic_param;
  D.29346 = D.29345->owner;
  method = D.29346->owner.method;
  D.29347 = method == 0B;
  D.29348 = (long int) D.29347;
  D.29349 = __builtin_expect (D.29348, 0);
  if (D.29349 != 0) goto <D.29350>; else goto <D.29351>;
  <D.29350>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "icall.c", 2570, "method");
  <D.29351>:
  D.29352 = method->klass;
  D.29353 = MEM[(struct MonoObject *)ref_type].vtable;
  D.29354 = D.29353->domain;
  D.29344 = mono_method_get_object (D.29354, method, D.29352);
  return D.29344;
}


ves_icall_get_type_parent (struct MonoReflectionType * type)
{
  struct MonoType * D.29356;
  struct MonoReflectionType * D.29357;
  struct MonoReflectionType * iftmp.193;
  struct MonoClass * D.29359;
  struct MonoType * D.29362;
  struct MonoVTable * D.29363;
  struct MonoDomain * D.29364;
  struct MonoClass * class;

  D.29356 = type->type;
  class = mono_class_from_mono_type (D.29356);
  D.29359 = class->parent;
  if (D.29359 != 0B) goto <D.29360>; else goto <D.29361>;
  <D.29360>:
  D.29359 = class->parent;
  D.29362 = &D.29359->byval_arg;
  D.29363 = MEM[(struct MonoObject *)type].vtable;
  D.29364 = D.29363->domain;
  iftmp.193 = mono_type_get_object (D.29364, D.29362);
  goto <D.29365>;
  <D.29361>:
  iftmp.193 = 0B;
  <D.29365>:
  D.29357 = iftmp.193;
  return D.29357;
}


ves_icall_MonoType_get_Assembly (struct MonoReflectionType * type)
{
  struct MonoType * D.29367;
  struct MonoReflectionAssembly * D.29368;
  struct MonoImage * D.29369;
  struct MonoAssembly * D.29370;
  struct MonoDomain * domain;
  struct MonoClass * class;

  domain = mono_domain_get ();
  D.29367 = type->type;
  class = mono_class_from_mono_type (D.29367);
  D.29369 = class->image;
  D.29370 = D.29369->assembly;
  D.29368 = mono_assembly_get_object (domain, D.29370);
  return D.29368;
}


ves_icall_System_MonoType_getFullName (struct MonoReflectionType * object, gboolean full_name, gboolean assembly_qualified)
{
  struct MonoVTable * D.29372;
  MonoTypeNameFormat iftmp.194;
  struct MonoType * D.29380;
  struct MonoString * D.29383;
  unsigned char D.29386;
  _Bool D.29387;
  _Bool D.29388;
  _Bool D.29389;
  struct MonoDomain * domain;
  MonoTypeNameFormat format;
  struct MonoString * res;
  gchar * name;

  D.29372 = MEM[(struct MonoObject *)object].vtable;
  domain = D.29372->domain;
  if (full_name != 0) goto <D.29373>; else goto <D.29374>;
  <D.29373>:
  if (assembly_qualified != 0) goto <D.29376>; else goto <D.29377>;
  <D.29376>:
  iftmp.194 = 3;
  goto <D.29378>;
  <D.29377>:
  iftmp.194 = 2;
  <D.29378>:
  format = iftmp.194;
  goto <D.29379>;
  <D.29374>:
  format = 1;
  <D.29379>:
  D.29380 = object->type;
  name = mono_type_get_name_full (D.29380, format);
  if (name == 0B) goto <D.29381>; else goto <D.29382>;
  <D.29381>:
  D.29383 = 0B;
  return D.29383;
  <D.29382>:
  if (full_name != 0) goto <D.29384>; else goto <D.29385>;
  <D.29384>:
  D.29380 = object->type;
  D.29386 = D.29380->type;
  D.29387 = D.29386 == 19;
  D.29388 = D.29386 == 30;
  D.29389 = D.29387 | D.29388;
  if (D.29389 != 0) goto <D.29390>; else goto <D.29391>;
  <D.29390>:
  monoeg_g_free (name);
  D.29383 = 0B;
  return D.29383;
  <D.29391>:
  <D.29385>:
  res = mono_string_new (domain, name);
  monoeg_g_free (name);
  D.29383 = res;
  return D.29383;
}


ves_icall_type_isprimitive (struct MonoReflectionType * type)
{
  MonoBoolean D.29393;
  int iftmp.195;
  struct MonoType * D.29398;
  unsigned char D.29399;
  unsigned char D.29400;
  unsigned char D.29402;
  unsigned char D.29403;
  _Bool D.29404;
  _Bool D.29405;
  _Bool D.29406;
  unsigned char D.29408;

  D.29398 = type->type;
  D.29399 = BIT_FIELD_REF <*D.29398, 8, 56>;
  D.29400 = D.29399 & 64;
  if (D.29400 == 0) goto <D.29401>; else goto <D.29395>;
  <D.29401>:
  D.29398 = type->type;
  D.29402 = D.29398->type;
  D.29403 = D.29402 + 254;
  D.29404 = D.29403 <= 11;
  D.29405 = D.29402 == 24;
  D.29406 = D.29404 | D.29405;
  if (D.29406 != 0) goto <D.29396>; else goto <D.29407>;
  <D.29407>:
  D.29398 = type->type;
  D.29408 = D.29398->type;
  if (D.29408 == 25) goto <D.29396>; else goto <D.29395>;
  <D.29396>:
  iftmp.195 = 1;
  goto <D.29397>;
  <D.29395>:
  iftmp.195 = 0;
  <D.29397>:
  D.29393 = (MonoBoolean) iftmp.195;
  return D.29393;
}


ves_icall_type_ispointer (struct MonoReflectionType * type)
{
  MonoBoolean D.29410;
  struct MonoType * D.29411;
  unsigned char D.29412;
  _Bool D.29413;

  D.29411 = type->type;
  D.29412 = D.29411->type;
  D.29413 = D.29412 == 15;
  D.29410 = (MonoBoolean) D.29413;
  return D.29410;
}


ves_icall_type_iscomobject (struct MonoReflectionType * type)
{
  struct MonoType * D.29415;
  MonoBoolean D.29416;
  <unnamed-unsigned:1> D.29417;
  struct MonoClass * klass;

  D.29415 = type->type;
  klass = mono_class_from_mono_type (D.29415);
  mono_class_init_or_throw (klass);
  D.29417 = klass->is_com_object;
  D.29416 = (MonoBoolean) D.29417;
  return D.29416;
}


ves_icall_type_isbyref (struct MonoReflectionType * type)
{
  MonoBoolean D.29419;
  struct MonoType * D.29420;
  <unnamed-unsigned:1> D.29421;

  D.29420 = type->type;
  D.29421 = D.29420->byref;
  D.29419 = (MonoBoolean) D.29421;
  return D.29419;
}


ves_icall_MonoType_GetEvent (struct MonoReflectionType * type, struct MonoString * name, guint32 bflags)
{
  struct MonoType * D.29423;
  unsigned char D.29424;
  unsigned char D.29425;
  struct MonoReflectionEvent * D.29428;
  struct MonoVTable * D.29429;
  int (*<T3926>) (const char *, const char *) iftmp.196;
  unsigned int D.29431;
  unsigned char D.29435;
  struct MonoException * D.29438;
  const char * D.29439;
  int D.29440;
  short unsigned int D.29449;
  int D.29450;
  int D.29451;
  unsigned int D.29454;
  unsigned int D.29458;
  int D.29465;
  unsigned int D.29468;
  unsigned int D.29471;
  unsigned int D.29477;
  unsigned int D.29483;
  struct MonoDomain * domain;
  struct MonoClass * klass;
  struct MonoClass * startklass;
  void * iter;
  struct MonoEvent * event;
  struct MonoMethod * method;
  gchar * event_name;
  int (*<T3926>) (const char *, const char *) compare_func;
  void handle_parent = <<< error >>>;

  try
    {
      event_name = mono_string_to_utf8 (name);
      D.29423 = type->type;
      D.29424 = BIT_FIELD_REF <*D.29423, 8, 56>;
      D.29425 = D.29424 & 64;
      if (D.29425 != 0) goto <D.29426>; else goto <D.29427>;
      <D.29426>:
      D.29428 = 0B;
      return D.29428;
      <D.29427>:
      D.29423 = type->type;
      startklass = mono_class_from_mono_type (D.29423);
      klass = startklass;
      D.29429 = MEM[(struct MonoObject *)type].vtable;
      domain = D.29429->domain;
      mono_class_init_or_throw (klass);
      D.29431 = bflags & 1;
      if (D.29431 != 0) goto <D.29432>; else goto <D.29433>;
      <D.29432>:
      iftmp.196 = monoeg_ascii_strcasecmp;
      goto <D.29434>;
      <D.29433>:
      iftmp.196 = strcmp;
      <D.29434>:
      compare_func = iftmp.196;
      handle_parent:
      D.29435 = klass->exception_type;
      if (D.29435 != 0) goto <D.29436>; else goto <D.29437>;
      <D.29436>:
      D.29438 = mono_class_get_exception_for_failure (klass);
      mono_raise_exception (D.29438);
      <D.29437>:
      iter = 0B;
      goto <D.22030>;
      <D.22031>:
      D.29439 = event->name;
      D.29440 = compare_func (D.29439, event_name);
      if (D.29440 != 0) goto <D.29441>; else goto <D.29442>;
      <D.29441>:
      // predicted unlikely by continue predictor.
      goto <D.22030>;
      <D.29442>:
      method = event->add;
      if (method == 0B) goto <D.29443>; else goto <D.29444>;
      <D.29443>:
      method = event->remove;
      <D.29444>:
      if (method == 0B) goto <D.29445>; else goto <D.29446>;
      <D.29445>:
      method = event->raise;
      <D.29446>:
      if (method != 0B) goto <D.29447>; else goto <D.29448>;
      <D.29447>:
      D.29449 = method->flags;
      D.29450 = (int) D.29449;
      D.29451 = D.29450 & 7;
      if (D.29451 == 6) goto <D.29452>; else goto <D.29453>;
      <D.29452>:
      D.29454 = bflags & 16;
      if (D.29454 == 0) goto <D.29455>; else goto <D.29456>;
      <D.29455>:
      // predicted unlikely by continue predictor.
      goto <D.22030>;
      <D.29456>:
      goto <D.29457>;
      <D.29453>:
      D.29458 = bflags & 32;
      if (D.29458 == 0) goto <D.29459>; else goto <D.29460>;
      <D.29459>:
      // predicted unlikely by continue predictor.
      goto <D.22030>;
      <D.29460>:
      if (klass != startklass) goto <D.29461>; else goto <D.29462>;
      <D.29461>:
      D.29449 = method->flags;
      D.29450 = (int) D.29449;
      D.29451 = D.29450 & 7;
      if (D.29451 == 1) goto <D.29463>; else goto <D.29464>;
      <D.29463>:
      // predicted unlikely by continue predictor.
      goto <D.22030>;
      <D.29464>:
      <D.29462>:
      <D.29457>:
      D.29449 = method->flags;
      D.29450 = (int) D.29449;
      D.29465 = D.29450 & 16;
      if (D.29465 != 0) goto <D.29466>; else goto <D.29467>;
      <D.29466>:
      D.29468 = bflags & 8;
      if (D.29468 == 0) goto <D.29469>; else goto <D.29470>;
      <D.29469>:
      // predicted unlikely by continue predictor.
      goto <D.22030>;
      <D.29470>:
      D.29471 = bflags & 64;
      if (D.29471 == 0) goto <D.29472>; else goto <D.29473>;
      <D.29472>:
      if (klass != startklass) goto <D.29474>; else goto <D.29475>;
      <D.29474>:
      // predicted unlikely by continue predictor.
      goto <D.22030>;
      <D.29475>:
      <D.29473>:
      goto <D.29476>;
      <D.29467>:
      D.29477 = bflags & 4;
      if (D.29477 == 0) goto <D.29478>; else goto <D.29479>;
      <D.29478>:
      // predicted unlikely by continue predictor.
      goto <D.22030>;
      <D.29479>:
      <D.29476>:
      goto <D.29480>;
      <D.29448>:
      D.29458 = bflags & 32;
      if (D.29458 == 0) goto <D.29481>; else goto <D.29482>;
      <D.29481>:
      // predicted unlikely by continue predictor.
      goto <D.22030>;
      <D.29482>:
      <D.29480>:
      monoeg_g_free (event_name);
      D.29428 = mono_event_get_object (domain, startklass, event);
      return D.29428;
      <D.22030>:
      event = mono_class_get_events (klass, &iter);
      if (event != 0B) goto <D.22031>; else goto <D.22032>;
      <D.22032>:
      D.29483 = bflags & 2;
      if (D.29483 == 0) goto <D.29484>; else goto <D.29485>;
      <D.29484>:
      klass = klass->parent;
      if (klass != 0B) goto handle_parent; else goto <D.29486>;
      <D.29486>:
      <D.29485>:
      monoeg_g_free (event_name);
      D.29428 = 0B;
      return D.29428;
    }
  finally
    {
      iter = {CLOBBER};
    }
}


ves_icall_Type_GetPropertiesByName (struct MonoReflectionType * type, struct MonoString * name, guint32 bflags, MonoBoolean ignore_case, struct MonoReflectionType * reftype)
{
  void * D.29489;
  struct MonoClass * System_Reflection_PropertyInfo.197;
  struct MonoImage * D.29493;
  struct MonoClass * System_Reflection_PropertyInfo.198;
  struct MonoVTable * D.29495;
  struct MonoType * D.29496;
  unsigned char D.29497;
  unsigned char D.29498;
  struct MonoArray * D.29501;
  struct MonoClass * D.22001;
  struct MonoClass * tmp_klass.199;
  struct MonoClass * tmp_klass.200;
  _Bool D.29506;
  long int D.29507;
  long int D.29508;
  struct MonoVTable * D.29511;
  int (*<T3926>) (const char *, const char *) iftmp.201;
  unsigned char D.29518;
  struct MonoLoaderError * D.29520;
  short unsigned int D.29526;
  struct MonoMethod * D.29532;
  short unsigned int D.29534;
  int D.29535;
  int D.29536;
  struct MonoMethod * D.29537;
  short unsigned int D.29539;
  int D.29540;
  int D.29541;
  unsigned int D.29542;
  unsigned int D.29545;
  _Bool D.29550;
  int D.29551;
  int D.29552;
  int D.29554;
  unsigned int D.29557;
  unsigned int D.29560;
  unsigned int D.29565;
  unsigned int D.29568;
  const char * D.29575;
  int D.29576;
  void * D.29579;
  int D.29582;
  int D.29583;
  int D.29586;
  void * D.29587;
  unsigned int D.29588;
  unsigned int D.29589;
  unsigned int D.29590;
  void * * D.29591;
  int D.29594;
  int D.29595;
  unsigned int D.29596;
  unsigned int D.29597;
  void * * D.29598;
  struct MonoReflectionProperty * D.29599;
  unsigned int D.29600;
  unsigned int D.29604;
  struct MonoClass * D.22009;
  struct MonoClass * tmp_klass.202;
  struct MonoClass * tmp_klass.203;
  _Bool D.29609;
  long int D.29610;
  long int D.29611;
  struct MonoVTable * D.29614;
  unsigned int i.204;
  unsigned int i.205;
  unsigned int D.29617;
  void * * D.29618;
  void * D.29619;
  struct MonoLoaderError * D.29631;
  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 (*<T3926>) (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.29489 = __builtin_alloca (64);
      tmp_array.data = D.29489;
      System_Reflection_PropertyInfo.197 = System_Reflection_PropertyInfo;
      if (System_Reflection_PropertyInfo.197 == 0B) goto <D.29491>; else goto <D.29492>;
      <D.29491>:
      D.29493 = mono_defaults.corlib;
      System_Reflection_PropertyInfo.198 = mono_class_from_name (D.29493, "System.Reflection", "PropertyInfo");
      System_Reflection_PropertyInfo = System_Reflection_PropertyInfo.198;
      <D.29492>:
      D.29495 = MEM[(struct MonoObject *)type].vtable;
      domain = D.29495->domain;
      D.29496 = type->type;
      D.29497 = BIT_FIELD_REF <*D.29496, 8, 56>;
      D.29498 = D.29497 & 64;
      if (D.29498 != 0) goto <D.29499>; else goto <D.29500>;
      <D.29499>:
      {
        static struct MonoClass * tmp_klass;

        {
          tmp_klass.199 = tmp_klass;
          if (tmp_klass.199 == 0B) goto <D.29503>; else goto <D.29504>;
          <D.29503>:
          System_Reflection_PropertyInfo.197 = System_Reflection_PropertyInfo;
          tmp_klass.200 = mono_array_class_get (System_Reflection_PropertyInfo.197, 1);
          tmp_klass = tmp_klass.200;
          tmp_klass.199 = tmp_klass;
          D.29506 = tmp_klass.199 == 0B;
          D.29507 = (long int) D.29506;
          D.29508 = __builtin_expect (D.29507, 0);
          if (D.29508 != 0) goto <D.29509>; else goto <D.29510>;
          <D.29509>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "icall.c", 3725, "tmp_klass");
          <D.29510>:
          <D.29504>:
        }
        D.22001 = tmp_klass;
      }
      D.29511 = mono_class_vtable (domain, D.22001);
      D.29501 = mono_array_new_specific (D.29511, 0);
      return D.29501;
      <D.29500>:
      D.29496 = type->type;
      startklass = mono_class_from_mono_type (D.29496);
      klass = startklass;
      if (name != 0B) goto <D.29512>; else goto <D.29513>;
      <D.29512>:
      propname = mono_string_to_utf8 (name);
      if (ignore_case != 0) goto <D.29515>; else goto <D.29516>;
      <D.29515>:
      iftmp.201 = monoeg_ascii_strcasecmp;
      goto <D.29517>;
      <D.29516>:
      iftmp.201 = strcmp;
      <D.29517>:
      compare_func = iftmp.201;
      <D.29513>:
      properties = monoeg_g_hash_table_new (property_hash, property_equal);
      handle_parent:
      mono_class_setup_vtable (klass);
      D.29518 = klass->exception_type;
      if (D.29518 != 0) goto loader_error; else goto <D.29519>;
      <D.29519>:
      D.29520 = mono_loader_get_last_error ();
      if (D.29520 != 0B) goto loader_error; else goto <D.29521>;
      <D.29521>:
      iter = 0B;
      goto <D.22004>;
      <D.22006>:
      match = 0;
      method = prop->get;
      if (method == 0B) goto <D.29522>; else goto <D.29523>;
      <D.29522>:
      method = prop->set;
      <D.29523>:
      if (method != 0B) goto <D.29524>; else goto <D.29525>;
      <D.29524>:
      D.29526 = method->flags;
      flags = (guint32) D.29526;
      goto <D.29527>;
      <D.29525>:
      flags = 0;
      <D.29527>:
      D.29532 = prop->get;
      if (D.29532 != 0B) goto <D.29533>; else goto <D.29528>;
      <D.29533>:
      D.29532 = prop->get;
      D.29534 = D.29532->flags;
      D.29535 = (int) D.29534;
      D.29536 = D.29535 & 7;
      if (D.29536 == 6) goto <D.29529>; else goto <D.29528>;
      <D.29528>:
      D.29537 = prop->set;
      if (D.29537 != 0B) goto <D.29538>; else goto <D.29530>;
      <D.29538>:
      D.29537 = prop->set;
      D.29539 = D.29537->flags;
      D.29540 = (int) D.29539;
      D.29541 = D.29540 & 7;
      if (D.29541 == 6) goto <D.29529>; else goto <D.29530>;
      <D.29529>:
      D.29542 = bflags & 16;
      if (D.29542 != 0) goto <D.29543>; else goto <D.29544>;
      <D.29543>:
      match = match + 1;
      <D.29544>:
      goto <D.29531>;
      <D.29530>:
      D.29545 = bflags & 32;
      if (D.29545 != 0) goto <D.29546>; else goto <D.29547>;
      <D.29546>:
      D.29550 = startklass == klass;
      D.29551 = (int) D.29550;
      D.29532 = prop->get;
      D.29552 = property_accessor_nonpublic (D.29532, D.29551);
      if (D.29552 != 0) goto <D.29548>; else goto <D.29553>;
      <D.29553>:
      D.29550 = startklass == klass;
      D.29551 = (int) D.29550;
      D.29537 = prop->set;
      D.29554 = property_accessor_nonpublic (D.29537, D.29551);
      if (D.29554 != 0) goto <D.29548>; else goto <D.29549>;
      <D.29548>:
      match = match + 1;
      <D.29549>:
      <D.29547>:
      <D.29531>:
      if (match == 0) goto <D.29555>; else goto <D.29556>;
      <D.29555>:
      // predicted unlikely by continue predictor.
      goto <D.22004>;
      <D.29556>:
      match = 0;
      D.29557 = flags & 16;
      if (D.29557 != 0) goto <D.29558>; else goto <D.29559>;
      <D.29558>:
      D.29560 = bflags & 8;
      if (D.29560 != 0) goto <D.29561>; else goto <D.29562>;
      <D.29561>:
      D.29565 = bflags & 64;
      if (D.29565 != 0) goto <D.29563>; else goto <D.29566>;
      <D.29566>:
      if (klass == startklass) goto <D.29563>; else goto <D.29564>;
      <D.29563>:
      match = match + 1;
      <D.29564>:
      <D.29562>:
      goto <D.29567>;
      <D.29559>:
      D.29568 = bflags & 4;
      if (D.29568 != 0) goto <D.29569>; else goto <D.29570>;
      <D.29569>:
      match = match + 1;
      <D.29570>:
      <D.29567>:
      if (match == 0) goto <D.29571>; else goto <D.29572>;
      <D.29571>:
      // predicted unlikely by continue predictor.
      goto <D.22004>;
      <D.29572>:
      match = 0;
      if (name != 0B) goto <D.29573>; else goto <D.29574>;
      <D.29573>:
      D.29575 = prop->name;
      D.29576 = compare_func (propname, D.29575);
      if (D.29576 != 0) goto <D.29577>; else goto <D.29578>;
      <D.29577>:
      // predicted unlikely by continue predictor.
      goto <D.22004>;
      <D.29578>:
      <D.29574>:
      D.29579 = monoeg_g_hash_table_lookup (properties, prop);
      if (D.29579 != 0B) goto <D.29580>; else goto <D.29581>;
      <D.29580>:
      // predicted unlikely by continue predictor.
      goto <D.22004>;
      <D.29581>:
      D.29582 = tmp_array.size;
      D.29583 = tmp_array.capacity;
      if (D.29582 >= D.29583) goto <D.29584>; else goto <D.29585>;
      <D.29584>:
      {
        void * __tmp;

        D.29583 = tmp_array.capacity;
        D.29586 = D.29583 * 2;
        D.29587 = mono_gc_make_root_descr_all_refs (D.29586);
        D.29583 = tmp_array.capacity;
        D.29588 = (unsigned int) D.29583;
        D.29589 = D.29588 * 8;
        __tmp = mono_gc_alloc_fixed (D.29589, D.29587);
        D.29583 = tmp_array.capacity;
        D.29588 = (unsigned int) D.29583;
        D.29590 = D.29588 * 4;
        D.29591 = tmp_array.data;
        mono_gc_memmove_aligned (__tmp, D.29591, D.29590);
        D.29583 = tmp_array.capacity;
        if (D.29583 > 16) goto <D.29592>; else goto <D.29593>;
        <D.29592>:
        D.29591 = tmp_array.data;
        mono_gc_free_fixed (D.29591);
        <D.29593>:
        tmp_array.data = __tmp;
        D.29583 = tmp_array.capacity;
        D.29586 = D.29583 * 2;
        tmp_array.capacity = D.29586;
      }
      <D.29585>:
      D.29591 = tmp_array.data;
      D.29582 = tmp_array.size;
      D.29594 = D.29582;
      D.29595 = D.29594 + 1;
      tmp_array.size = D.29595;
      D.29596 = (unsigned int) D.29594;
      D.29597 = D.29596 * 4;
      D.29598 = D.29591 + D.29597;
      D.29599 = mono_property_get_object (domain, startklass, prop);
      *D.29598 = D.29599;
      monoeg_g_hash_table_insert_replace (properties, prop, prop, 0);
      <D.22004>:
      prop = mono_class_get_properties (klass, &iter);
      if (prop != 0B) goto <D.22006>; else goto <D.22007>;
      <D.22007>:
      D.29600 = bflags & 2;
      if (D.29600 == 0) goto <D.29601>; else goto <D.29602>;
      <D.29601>:
      klass = klass->parent;
      if (klass != 0B) goto handle_parent; else goto <D.29603>;
      <D.29603>:
      <D.29602>:
      monoeg_g_hash_table_destroy (properties);
      monoeg_g_free (propname);
      D.29582 = tmp_array.size;
      D.29604 = (unsigned int) D.29582;
      {
        static struct MonoClass * tmp_klass;

        {
          tmp_klass.202 = tmp_klass;
          if (tmp_klass.202 == 0B) goto <D.29606>; else goto <D.29607>;
          <D.29606>:
          System_Reflection_PropertyInfo.197 = System_Reflection_PropertyInfo;
          tmp_klass.203 = mono_array_class_get (System_Reflection_PropertyInfo.197, 1);
          tmp_klass = tmp_klass.203;
          tmp_klass.202 = tmp_klass;
          D.29609 = tmp_klass.202 == 0B;
          D.29610 = (long int) D.29609;
          D.29611 = __builtin_expect (D.29610, 0);
          if (D.29611 != 0) goto <D.29612>; else goto <D.29613>;
          <D.29612>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "icall.c", 3793, "tmp_klass");
          <D.29613>:
          <D.29607>:
        }
        D.22009 = tmp_klass;
      }
      D.29614 = mono_class_vtable (domain, D.22009);
      res = mono_array_new_specific (D.29614, D.29604);
      i = 0;
      goto <D.22012>;
      <D.22011>:
      {
        void * * __p;

        i.204 = (unsigned int) i;
        __p = mono_array_addr_with_size (res, 4, i.204);
        D.29591 = tmp_array.data;
        i.205 = (unsigned int) i;
        D.29617 = i.205 * 4;
        D.29618 = D.29591 + D.29617;
        D.29619 = *D.29618;
        mono_gc_wbarrier_set_arrayref (res, __p, D.29619);
      }
      i = i + 1;
      <D.22012>:
      D.29582 = tmp_array.size;
      if (D.29582 > i) goto <D.22011>; else goto <D.22013>;
      <D.22013>:
      D.29583 = tmp_array.capacity;
      if (D.29583 > 16) goto <D.29620>; else goto <D.29621>;
      <D.29620>:
      D.29591 = tmp_array.data;
      mono_gc_free_fixed (D.29591);
      <D.29621>:
      D.29501 = res;
      return D.29501;
      loader_error:
      if (properties != 0B) goto <D.29622>; else goto <D.29623>;
      <D.29622>:
      monoeg_g_hash_table_destroy (properties);
      <D.29623>:
      if (name != 0B) goto <D.29624>; else goto <D.29625>;
      <D.29624>:
      monoeg_g_free (propname);
      <D.29625>:
      D.29583 = tmp_array.capacity;
      if (D.29583 > 16) goto <D.29626>; else goto <D.29627>;
      <D.29626>:
      D.29591 = tmp_array.data;
      mono_gc_free_fixed (D.29591);
      <D.29627>:
      D.29518 = klass->exception_type;
      if (D.29518 != 0) goto <D.29628>; else goto <D.29629>;
      <D.29628>:
      ex = mono_class_get_exception_for_failure (klass);
      goto <D.29630>;
      <D.29629>:
      D.29631 = mono_loader_get_last_error ();
      ex = mono_loader_error_prepare_exception (D.29631);
      mono_loader_clear_error ();
      <D.29630>:
      mono_raise_exception (ex);
      D.29501 = 0B;
      return D.29501;
    }
  finally
    {
      iter = {CLOBBER};
      tmp_array = {CLOBBER};
    }
}


property_equal (struct MonoProperty * prop1, struct MonoProperty * prop2)
{
  const char * D.29634;
  const char * D.29635;
  int D.29636;
  gboolean D.29639;
  struct MonoMethod * D.29640;
  struct MonoMethod * D.29643;
  struct MonoMethodSignature * D.29646;
  struct MonoMethodSignature * D.29647;
  int D.29648;
  struct MonoMethod * D.29651;
  struct MonoMethod * D.29654;
  struct MonoMethodSignature * D.29657;
  struct MonoMethodSignature * D.29658;
  int D.29659;

  D.29634 = prop2->name;
  D.29635 = prop1->name;
  D.29636 = monoeg_g_str_equal (D.29635, D.29634);
  if (D.29636 == 0) goto <D.29637>; else goto <D.29638>;
  <D.29637>:
  D.29639 = 0;
  return D.29639;
  <D.29638>:
  D.29640 = prop1->get;
  if (D.29640 != 0B) goto <D.29641>; else goto <D.29642>;
  <D.29641>:
  D.29643 = prop2->get;
  if (D.29643 != 0B) goto <D.29644>; else goto <D.29645>;
  <D.29644>:
  D.29643 = prop2->get;
  D.29646 = mono_method_signature (D.29643);
  D.29640 = prop1->get;
  D.29647 = mono_method_signature (D.29640);
  D.29648 = mono_metadata_signature_equal (D.29647, D.29646);
  if (D.29648 == 0) goto <D.29649>; else goto <D.29650>;
  <D.29649>:
  D.29639 = 0;
  return D.29639;
  <D.29650>:
  <D.29645>:
  <D.29642>:
  D.29651 = prop1->set;
  if (D.29651 != 0B) goto <D.29652>; else goto <D.29653>;
  <D.29652>:
  D.29654 = prop2->set;
  if (D.29654 != 0B) goto <D.29655>; else goto <D.29656>;
  <D.29655>:
  D.29654 = prop2->set;
  D.29657 = mono_method_signature (D.29654);
  D.29651 = prop1->set;
  D.29658 = mono_method_signature (D.29651);
  D.29659 = mono_metadata_signature_equal (D.29658, D.29657);
  if (D.29659 == 0) goto <D.29660>; else goto <D.29661>;
  <D.29660>:
  D.29639 = 0;
  return D.29639;
  <D.29661>:
  <D.29656>:
  <D.29653>:
  D.29639 = 1;
  return D.29639;
}


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

  prop = data;
  D.29664 = prop->name;
  D.29663 = monoeg_g_str_hash (D.29664);
  return D.29663;
}


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

  if (accessor == 0B) goto <D.29666>; else goto <D.29667>;
  <D.29666>:
  D.29668 = 0;
  return D.29668;
  <D.29667>:
  D.29668 = method_nonpublic (accessor, start_klass);
  return D.29668;
}


ves_icall_Type_GetNestedTypes (struct MonoReflectionType * type, guint32 bflags)
{
  struct MonoVTable * D.29670;
  struct MonoType * D.29671;
  unsigned char D.29672;
  unsigned char D.29673;
  struct MonoArray * D.29676;
  struct MonoClass * D.29677;
  struct MonoGenericClass * D.29678;
  void * D.29681;
  unsigned int D.29682;
  unsigned int D.29683;
  unsigned int D.29686;
  unsigned int D.29690;
  struct MonoType * D.29695;
  int D.29696;
  int D.29697;
  int D.29700;
  void * D.29701;
  unsigned int D.29702;
  unsigned int D.29703;
  unsigned int D.29704;
  void * * D.29705;
  int D.29708;
  int D.29709;
  unsigned int D.29710;
  unsigned int D.29711;
  void * * D.29712;
  unsigned int D.29713;
  struct MonoClass * D.22106;
  struct MonoClass * tmp_klass.206;
  struct MonoClass * tmp_klass.207;
  _Bool D.29718;
  long int D.29719;
  long int D.29720;
  struct MonoVTable * D.29723;
  unsigned int i.208;
  unsigned int i.209;
  unsigned int D.29726;
  void * * D.29727;
  void * D.29728;
  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.29670 = MEM[(struct MonoObject *)type].vtable;
      domain = D.29670->domain;
      D.29671 = type->type;
      D.29672 = BIT_FIELD_REF <*D.29671, 8, 56>;
      D.29673 = D.29672 & 64;
      if (D.29673 != 0) goto <D.29674>; else goto <D.29675>;
      <D.29674>:
      D.29677 = mono_defaults.monotype_class;
      D.29676 = mono_array_new (domain, D.29677, 0);
      return D.29676;
      <D.29675>:
      D.29671 = type->type;
      klass = mono_class_from_mono_type (D.29671);
      D.29678 = klass->generic_class;
      if (D.29678 != 0B) goto <D.29679>; else goto <D.29680>;
      <D.29679>:
      D.29678 = klass->generic_class;
      klass = D.29678->container_class;
      <D.29680>:
      tmp_array.size = 0;
      tmp_array.capacity = 16;
      D.29681 = __builtin_alloca (64);
      tmp_array.data = D.29681;
      iter = 0B;
      goto <D.22101>;
      <D.22103>:
      match = 0;
      D.29682 = nested->flags;
      D.29683 = D.29682 & 7;
      if (D.29683 == 2) goto <D.29684>; else goto <D.29685>;
      <D.29684>:
      D.29686 = bflags & 16;
      if (D.29686 != 0) goto <D.29687>; else goto <D.29688>;
      <D.29687>:
      match = match + 1;
      <D.29688>:
      goto <D.29689>;
      <D.29685>:
      D.29690 = bflags & 32;
      if (D.29690 != 0) goto <D.29691>; else goto <D.29692>;
      <D.29691>:
      match = match + 1;
      <D.29692>:
      <D.29689>:
      if (match == 0) goto <D.29693>; else goto <D.29694>;
      <D.29693>:
      // predicted unlikely by continue predictor.
      goto <D.22101>;
      <D.29694>:
      D.29695 = &nested->byval_arg;
      member = mono_type_get_object (domain, D.29695);
      D.29696 = tmp_array.size;
      D.29697 = tmp_array.capacity;
      if (D.29696 >= D.29697) goto <D.29698>; else goto <D.29699>;
      <D.29698>:
      {
        void * __tmp;

        D.29697 = tmp_array.capacity;
        D.29700 = D.29697 * 2;
        D.29701 = mono_gc_make_root_descr_all_refs (D.29700);
        D.29697 = tmp_array.capacity;
        D.29702 = (unsigned int) D.29697;
        D.29703 = D.29702 * 8;
        __tmp = mono_gc_alloc_fixed (D.29703, D.29701);
        D.29697 = tmp_array.capacity;
        D.29702 = (unsigned int) D.29697;
        D.29704 = D.29702 * 4;
        D.29705 = tmp_array.data;
        mono_gc_memmove_aligned (__tmp, D.29705, D.29704);
        D.29697 = tmp_array.capacity;
        if (D.29697 > 16) goto <D.29706>; else goto <D.29707>;
        <D.29706>:
        D.29705 = tmp_array.data;
        mono_gc_free_fixed (D.29705);
        <D.29707>:
        tmp_array.data = __tmp;
        D.29697 = tmp_array.capacity;
        D.29700 = D.29697 * 2;
        tmp_array.capacity = D.29700;
      }
      <D.29699>:
      D.29705 = tmp_array.data;
      D.29696 = tmp_array.size;
      D.29708 = D.29696;
      D.29709 = D.29708 + 1;
      tmp_array.size = D.29709;
      D.29710 = (unsigned int) D.29708;
      D.29711 = D.29710 * 4;
      D.29712 = D.29705 + D.29711;
      *D.29712 = member;
      <D.22101>:
      nested = mono_class_get_nested_types (klass, &iter);
      if (nested != 0B) goto <D.22103>; else goto <D.22104>;
      <D.22104>:
      D.29696 = tmp_array.size;
      D.29713 = (unsigned int) D.29696;
      {
        static struct MonoClass * tmp_klass;

        {
          tmp_klass.206 = tmp_klass;
          if (tmp_klass.206 == 0B) goto <D.29715>; else goto <D.29716>;
          <D.29715>:
          D.29677 = mono_defaults.monotype_class;
          tmp_klass.207 = mono_array_class_get (D.29677, 1);
          tmp_klass = tmp_klass.207;
          tmp_klass.206 = tmp_klass;
          D.29718 = tmp_klass.206 == 0B;
          D.29719 = (long int) D.29718;
          D.29720 = __builtin_expect (D.29719, 0);
          if (D.29720 != 0) goto <D.29721>; else goto <D.29722>;
          <D.29721>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "icall.c", 4094, "tmp_klass");
          <D.29722>:
          <D.29716>:
        }
        D.22106 = tmp_klass;
      }
      D.29723 = mono_class_vtable (domain, D.22106);
      res = mono_array_new_specific (D.29723, D.29713);
      i = 0;
      goto <D.22109>;
      <D.22108>:
      {
        void * * __p;

        i.208 = (unsigned int) i;
        __p = mono_array_addr_with_size (res, 4, i.208);
        D.29705 = tmp_array.data;
        i.209 = (unsigned int) i;
        D.29726 = i.209 * 4;
        D.29727 = D.29705 + D.29726;
        D.29728 = *D.29727;
        mono_gc_wbarrier_set_arrayref (res, __p, D.29728);
      }
      i = i + 1;
      <D.22109>:
      D.29696 = tmp_array.size;
      if (D.29696 > i) goto <D.22108>; else goto <D.22110>;
      <D.22110>:
      D.29697 = tmp_array.capacity;
      if (D.29697 > 16) goto <D.29729>; else goto <D.29730>;
      <D.29729>:
      D.29705 = tmp_array.data;
      mono_gc_free_fixed (D.29705);
      <D.29730>:
      D.29676 = res;
      return D.29676;
    }
  finally
    {
      iter = {CLOBBER};
      tmp_array = {CLOBBER};
    }
}


ves_icall_Type_GetNestedType (struct MonoReflectionType * type, struct MonoString * name, guint32 bflags)
{
  struct MonoException * D.29735;
  struct MonoVTable * D.29736;
  struct MonoType * D.29737;
  unsigned char D.29738;
  unsigned char D.29739;
  struct MonoReflectionType * D.29742;
  unsigned char D.29743;
  struct MonoException * D.29746;
  struct MonoGenericClass * D.29747;
  unsigned int D.29750;
  unsigned int D.29751;
  unsigned int D.29754;
  unsigned int D.29758;
  int D.22085;
  const char * D.29763;
  struct MonoType * D.29766;
  unsigned int D.29767;
  struct MonoDomain * domain;
  struct MonoClass * klass;
  struct MonoClass * nested;
  char * str;
  void * iter;
  void handle_parent = <<< error >>>;

  try
    {
      if (name == 0B) goto <D.29733>; else goto <D.29734>;
      <D.29733>:
      D.29735 = mono_get_exception_argument_null ("name");
      mono_raise_exception (D.29735);
      <D.29734>:
      D.29736 = MEM[(struct MonoObject *)type].vtable;
      domain = D.29736->domain;
      D.29737 = type->type;
      D.29738 = BIT_FIELD_REF <*D.29737, 8, 56>;
      D.29739 = D.29738 & 64;
      if (D.29739 != 0) goto <D.29740>; else goto <D.29741>;
      <D.29740>:
      D.29742 = 0B;
      return D.29742;
      <D.29741>:
      D.29737 = type->type;
      klass = mono_class_from_mono_type (D.29737);
      str = mono_string_to_utf8 (name);
      handle_parent:
      D.29743 = klass->exception_type;
      if (D.29743 != 0) goto <D.29744>; else goto <D.29745>;
      <D.29744>:
      D.29746 = mono_class_get_exception_for_failure (klass);
      mono_raise_exception (D.29746);
      <D.29745>:
      D.29747 = klass->generic_class;
      if (D.29747 != 0B) goto <D.29748>; else goto <D.29749>;
      <D.29748>:
      D.29747 = klass->generic_class;
      klass = D.29747->container_class;
      <D.29749>:
      iter = 0B;
      goto <D.22076>;
      <D.22086>:
      {
        int match;

        match = 0;
        D.29750 = nested->flags;
        D.29751 = D.29750 & 7;
        if (D.29751 == 2) goto <D.29752>; else goto <D.29753>;
        <D.29752>:
        D.29754 = bflags & 16;
        if (D.29754 != 0) goto <D.29755>; else goto <D.29756>;
        <D.29755>:
        match = match + 1;
        <D.29756>:
        goto <D.29757>;
        <D.29753>:
        D.29758 = bflags & 32;
        if (D.29758 != 0) goto <D.29759>; else goto <D.29760>;
        <D.29759>:
        match = match + 1;
        <D.29760>:
        <D.29757>:
        if (match == 0) goto <D.29761>; else goto <D.29762>;
        <D.29761>:
        // predicted unlikely by continue predictor.
        goto <D.22076>;
        <D.29762>:
        {
          size_t __s1_len;
          size_t __s2_len;

          D.29763 = nested->name;
          D.22085 = __builtin_strcmp (D.29763, str);
        }
        if (D.22085 == 0) goto <D.29764>; else goto <D.29765>;
        <D.29764>:
        monoeg_g_free (str);
        D.29766 = &nested->byval_arg;
        D.29742 = mono_type_get_object (domain, D.29766);
        return D.29742;
        <D.29765>:
      }
      <D.22076>:
      nested = mono_class_get_nested_types (klass, &iter);
      if (nested != 0B) goto <D.22086>; else goto <D.22087>;
      <D.22087>:
      D.29767 = bflags & 2;
      if (D.29767 == 0) goto <D.29768>; else goto <D.29769>;
      <D.29768>:
      klass = klass->parent;
      if (klass != 0B) goto handle_parent; else goto <D.29770>;
      <D.29770>:
      <D.29769>:
      monoeg_g_free (str);
      D.29742 = 0B;
      return D.29742;
    }
  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.210;
  struct MonoClass * D.29776;
  struct MonoType * D.29777;
  struct MonoType * D.29778;
  struct MonoVTable * D.29779;
  unsigned char D.29780;
  unsigned char D.29781;
  struct MonoArray * D.29784;
  int D.29787;
  struct MonoException * ex.211;
  unsigned int D.29791;
  void * * D.29792;
  unsigned int i.212;
  unsigned int D.29794;
  void * * D.29795;
  unsigned int i.213;
  struct MonoReflectionMethod * D.29797;
  unsigned int i.214;
  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.210 = MethodInfo_array;
      if (MethodInfo_array.210 == 0B) goto <D.29774>; else goto <D.29775>;
      <D.29774>:
      {
        struct MonoClass * klass;

        D.29776 = mono_defaults.method_info_class;
        klass = mono_array_class_get (D.29776, 1);
        mono_memory_barrier ();
        MethodInfo_array = klass;
      }
      <D.29775>:
      D.29777 = type->type;
      klass = mono_class_from_mono_type (D.29777);
      D.29778 = reftype->type;
      refklass = mono_class_from_mono_type (D.29778);
      D.29779 = MEM[(struct MonoObject *)type].vtable;
      domain = D.29779->domain;
      MethodInfo_array.210 = MethodInfo_array;
      array_vtable = mono_class_vtable_full (domain, MethodInfo_array.210, 1);
      D.29777 = type->type;
      D.29780 = BIT_FIELD_REF <*D.29777, 8, 56>;
      D.29781 = D.29780 & 64;
      if (D.29781 != 0) goto <D.29782>; else goto <D.29783>;
      <D.29782>:
      D.29784 = mono_array_new_specific (array_vtable, 0);
      return D.29784;
      <D.29783>:
      if (name != 0B) goto <D.29785>; else goto <D.29786>;
      <D.29785>:
      mname = mono_string_to_utf8 (name);
      <D.29786>:
      D.29787 = (int) ignore_case;
      method_array = mono_class_get_methods_by_name (klass, mname, bflags, D.29787, 0, &ex);
      monoeg_g_free (mname);
      ex.211 = ex;
      if (ex.211 != 0B) goto <D.29789>; else goto <D.29790>;
      <D.29789>:
      ex.211 = ex;
      mono_raise_exception (ex.211);
      <D.29790>:
      D.29791 = method_array->len;
      res = mono_array_new_specific (array_vtable, D.29791);
      i = 0;
      goto <D.21914>;
      <D.21913>:
      {
        struct MonoMethod * method;

        D.29792 = method_array->pdata;
        i.212 = (unsigned int) i;
        D.29794 = i.212 * 4;
        D.29795 = D.29792 + D.29794;
        method = *D.29795;
        {
          void * * __p;

          i.213 = (unsigned int) i;
          __p = mono_array_addr_with_size (res, 4, i.213);
          D.29797 = mono_method_get_object (domain, method, refklass);
          mono_gc_wbarrier_set_arrayref (res, __p, D.29797);
        }
      }
      i = i + 1;
      <D.21914>:
      i.214 = (unsigned int) i;
      D.29791 = method_array->len;
      if (i.214 < D.29791) goto <D.21913>; else goto <D.21915>;
      <D.21915>:
      monoeg_g_ptr_array_free (method_array, 1);
      D.29784 = res;
      return D.29784;
    }
  finally
    {
      ex = {CLOBBER};
    }
}


mono_memory_barrier ()
{
  __sync_synchronize ();
}


ves_icall_Type_GetInterfaces (struct MonoReflectionType * type)
{
  struct MonoType * D.29801;
  struct MonoGenericClass * D.29802;
  struct MonoGenericInst * D.29805;
  unsigned char D.29806;
  unsigned char D.29807;
  struct MonoGenericContext * D.29810;
  int D.29811;
  int D.29813;
  struct MonoVTable * D.29815;
  struct MonoDomain * D.29816;
  unsigned int D.29817;
  struct MonoDomain * D.29820;
  struct MonoArray * D.29821;
  struct MonoClass * D.21239;
  struct MonoClass * tmp_klass.215;
  struct MonoClass * D.29827;
  struct MonoClass * tmp_klass.216;
  _Bool D.29829;
  long int D.29830;
  long int D.29831;
  struct MonoVTable * D.29834;
  struct MonoArray * D.29835;
  struct MonoArray * D.29836;
  unsigned int len.217;
  struct MonoClass * D.21241;
  struct MonoClass * tmp_klass.218;
  struct MonoClass * tmp_klass.219;
  _Bool D.29842;
  long int D.29843;
  long int D.29844;
  struct MonoVTable * D.29847;
  struct MonoArray * D.29848;
  int D.29849;
  struct MonoError error;
  struct MonoClass * class;
  struct MonoClass * parent;
  struct FillIfaceArrayData data;
  int len;
  struct GHashTable * iface_hash;
  void fail = <<< error >>>;

  try
    {
      D.29801 = type->type;
      class = mono_class_from_mono_type (D.29801);
      data = {};
      iface_hash = monoeg_g_hash_table_new (0B, 0B);
      D.29802 = class->generic_class;
      if (D.29802 != 0B) goto <D.29803>; else goto <D.29804>;
      <D.29803>:
      D.29802 = class->generic_class;
      D.29805 = D.29802->context.class_inst;
      D.29806 = BIT_FIELD_REF <*D.29805, 8, 48>;
      D.29807 = D.29806 & 64;
      if (D.29807 != 0) goto <D.29808>; else goto <D.29809>;
      <D.29808>:
      D.29810 = mono_class_get_context (class);
      data.context = D.29810;
      D.29802 = class->generic_class;
      class = D.29802->container_class;
      <D.29809>:
      <D.29804>:
      parent = class;
      goto <D.21236>;
      <D.21235>:
      mono_class_setup_interfaces (parent, &error);
      D.29811 = mono_error_ok (&error);
      if (D.29811 == 0) goto fail; else goto <D.29812>;
      <D.29812>:
      collect_interfaces (parent, iface_hash, &error);
      D.29813 = mono_error_ok (&error);
      if (D.29813 == 0) goto fail; else goto <D.29814>;
      <D.29814>:
      parent = parent->parent;
      <D.21236>:
      if (parent != 0B) goto <D.21235>; else goto <D.21237>;
      <D.21237>:
      data.error = &error;
      D.29815 = MEM[(struct MonoObject *)type].vtable;
      D.29816 = D.29815->domain;
      data.domain = D.29816;
      D.29817 = monoeg_g_hash_table_size (iface_hash);
      len = (int) D.29817;
      if (len == 0) goto <D.29818>; else goto <D.29819>;
      <D.29818>:
      monoeg_g_hash_table_destroy (iface_hash);
      D.29820 = data.domain;
      D.29821 = D.29820->empty_types;
      if (D.29821 == 0B) goto <D.29822>; else goto <D.29823>;
      <D.29822>:
      D.29820 = data.domain;
      {
        static struct MonoClass * tmp_klass;

        {
          tmp_klass.215 = tmp_klass;
          if (tmp_klass.215 == 0B) goto <D.29825>; else goto <D.29826>;
          <D.29825>:
          D.29827 = mono_defaults.monotype_class;
          tmp_klass.216 = mono_array_class_get (D.29827, 1);
          tmp_klass = tmp_klass.216;
          tmp_klass.215 = tmp_klass;
          D.29829 = tmp_klass.215 == 0B;
          D.29830 = (long int) D.29829;
          D.29831 = __builtin_expect (D.29830, 0);
          if (D.29831 != 0) goto <D.29832>; else goto <D.29833>;
          <D.29832>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "icall.c", 2107, "tmp_klass");
          <D.29833>:
          <D.29826>:
        }
        D.21239 = tmp_klass;
      }
      D.29820 = data.domain;
      D.29834 = mono_class_vtable (D.29820, D.21239);
      D.29835 = mono_array_new_specific (D.29834, 0);
      D.29820->empty_types = D.29835;
      <D.29823>:
      D.29820 = data.domain;
      D.29836 = D.29820->empty_types;
      return D.29836;
      <D.29819>:
      len.217 = (unsigned int) len;
      {
        static struct MonoClass * tmp_klass;

        {
          tmp_klass.218 = tmp_klass;
          if (tmp_klass.218 == 0B) goto <D.29839>; else goto <D.29840>;
          <D.29839>:
          D.29827 = mono_defaults.monotype_class;
          tmp_klass.219 = mono_array_class_get (D.29827, 1);
          tmp_klass = tmp_klass.219;
          tmp_klass.218 = tmp_klass;
          D.29842 = tmp_klass.218 == 0B;
          D.29843 = (long int) D.29842;
          D.29844 = __builtin_expect (D.29843, 0);
          if (D.29844 != 0) goto <D.29845>; else goto <D.29846>;
          <D.29845>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "icall.c", 2111, "tmp_klass");
          <D.29846>:
          <D.29840>:
        }
        D.21241 = tmp_klass;
      }
      D.29820 = data.domain;
      D.29847 = mono_class_vtable (D.29820, D.21241);
      D.29848 = mono_array_new_specific (D.29847, len.217);
      data.iface_array = D.29848;
      monoeg_g_hash_table_foreach (iface_hash, fill_iface_array, &data);
      D.29849 = mono_error_ok (&error);
      if (D.29849 == 0) goto fail; else goto <D.29850>;
      <D.29850>:
      monoeg_g_hash_table_destroy (iface_hash);
      D.29836 = data.iface_array;
      return D.29836;
      fail:
      monoeg_g_hash_table_destroy (iface_hash);
      mono_error_raise_exception (&error);
      D.29836 = 0B;
      return D.29836;
    }
  finally
    {
      error = {CLOBBER};
      data = {CLOBBER};
    }
}


fill_iface_array (void * key, void * value, void * user_data)
{
  struct MonoError * D.29853;
  int D.29854;
  struct MonoGenericContext * D.29857;
  struct MonoGenericClass * D.29860;
  struct MonoGenericInst * D.29863;
  unsigned char D.29864;
  unsigned char D.29865;
  int D.29868;
  int D.29871;
  int D.29872;
  int D.29873;
  unsigned int D.29874;
  struct MonoArray * D.29875;
  struct MonoDomain * D.29876;
  struct MonoReflectionType * D.29877;
  struct FillIfaceArrayData * data;
  struct MonoClass * ic;
  struct MonoType * ret;
  struct MonoType * inflated;

  data = user_data;
  ic = key;
  ret = &ic->byval_arg;
  inflated = 0B;
  D.29853 = data->error;
  D.29854 = mono_error_ok (D.29853);
  if (D.29854 == 0) goto <D.29855>; else goto <D.29856>;
  <D.29855>:
  return;
  <D.29856>:
  D.29857 = data->context;
  if (D.29857 != 0B) goto <D.29858>; else goto <D.29859>;
  <D.29858>:
  D.29860 = ic->generic_class;
  if (D.29860 != 0B) goto <D.29861>; else goto <D.29862>;
  <D.29861>:
  D.29860 = ic->generic_class;
  D.29863 = D.29860->context.class_inst;
  D.29864 = BIT_FIELD_REF <*D.29863, 8, 48>;
  D.29865 = D.29864 & 64;
  if (D.29865 != 0) goto <D.29866>; else goto <D.29867>;
  <D.29866>:
  D.29853 = data->error;
  D.29857 = data->context;
  ret = mono_class_inflate_generic_type_checked (ret, D.29857, D.29853);
  inflated = ret;
  D.29853 = data->error;
  D.29868 = mono_error_ok (D.29853);
  if (D.29868 == 0) goto <D.29869>; else goto <D.29870>;
  <D.29869>:
  return;
  <D.29870>:
  <D.29867>:
  <D.29862>:
  <D.29859>:
  {
    void * * __p;

    D.29871 = data->next_idx;
    D.29872 = D.29871;
    D.29873 = D.29872 + 1;
    data->next_idx = D.29873;
    D.29874 = (unsigned int) D.29872;
    D.29875 = data->iface_array;
    __p = mono_array_addr_with_size (D.29875, 4, D.29874);
    D.29876 = data->domain;
    D.29877 = mono_type_get_object (D.29876, ret);
    D.29875 = data->iface_array;
    mono_gc_wbarrier_set_arrayref (D.29875, __p, D.29877);
  }
  if (inflated != 0B) goto <D.29878>; else goto <D.29879>;
  <D.29878>:
  mono_metadata_free_type (inflated);
  <D.29879>:
}


collect_interfaces (struct MonoClass * klass, struct GHashTable * ifaces, struct MonoError * error)
{
  int D.29881;
  struct MonoClass * * D.29884;
  unsigned int i.220;
  unsigned int D.29886;
  struct MonoClass * * D.29887;
  int D.29888;
  short unsigned int D.29891;
  int D.29892;
  int i;
  struct MonoClass * ic;

  mono_class_setup_interfaces (klass, error);
  D.29881 = mono_error_ok (error);
  if (D.29881 == 0) goto <D.29882>; else goto <D.29883>;
  <D.29882>:
  return;
  <D.29883>:
  i = 0;
  goto <D.21206>;
  <D.21205>:
  D.29884 = klass->interfaces;
  i.220 = (unsigned int) i;
  D.29886 = i.220 * 4;
  D.29887 = D.29884 + D.29886;
  ic = *D.29887;
  monoeg_g_hash_table_insert_replace (ifaces, ic, ic, 0);
  collect_interfaces (ic, ifaces, error);
  D.29888 = mono_error_ok (error);
  if (D.29888 == 0) goto <D.29889>; else goto <D.29890>;
  <D.29889>:
  return;
  <D.29890>:
  i = i + 1;
  <D.21206>:
  D.29891 = klass->interface_count;
  D.29892 = (int) D.29891;
  if (D.29892 > i) goto <D.21205>; else goto <D.21207>;
  <D.21207>:
}


ves_icall_MonoType_GetGenericArguments (struct MonoReflectionType * type)
{
  struct MonoVTable * D.29894;
  struct MonoClass * D.21333;
  struct MonoClass * tmp_klass.221;
  struct MonoClass * D.29898;
  struct MonoClass * tmp_klass.222;
  _Bool D.29900;
  long int D.29901;
  long int D.29902;
  struct MonoType * D.29905;
  struct MonoGenericContainer * D.29906;
  <unnamed-signed:31> D.29909;
  unsigned int D.29910;
  struct MonoImage * D.29911;
  struct MonoGenericParamFull * D.29912;
  unsigned int i.223;
  unsigned int D.29914;
  struct MonoGenericParam * D.29915;
  unsigned int i.224;
  struct MonoType * D.29917;
  struct MonoReflectionType * D.29918;
  int D.29919;
  struct MonoGenericClass * D.29921;
  <unnamed-unsigned:22> D.29924;
  unsigned int D.29925;
  struct MonoType * D.29926;
  struct MonoReflectionType * D.29927;
  int D.29928;
  struct MonoArray * D.29930;
  struct MonoArray * res;
  struct MonoClass * klass;
  struct MonoClass * pklass;
  struct MonoDomain * domain;
  struct MonoVTable * array_vtable;
  int i;

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

    {
      tmp_klass.221 = tmp_klass;
      if (tmp_klass.221 == 0B) goto <D.29896>; else goto <D.29897>;
      <D.29896>:
      D.29898 = mono_defaults.systemtype_class;
      tmp_klass.222 = mono_array_class_get (D.29898, 1);
      tmp_klass = tmp_klass.222;
      tmp_klass.221 = tmp_klass;
      D.29900 = tmp_klass.221 == 0B;
      D.29901 = (long int) D.29900;
      D.29902 = __builtin_expect (D.29901, 0);
      if (D.29902 != 0) goto <D.29903>; else goto <D.29904>;
      <D.29903>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "icall.c", 2329, "tmp_klass");
      <D.29904>:
      <D.29897>:
    }
    D.21333 = tmp_klass;
  }
  array_vtable = mono_class_vtable_full (domain, D.21333, 1);
  D.29905 = type->type;
  klass = mono_class_from_mono_type (D.29905);
  D.29906 = klass->generic_container;
  if (D.29906 != 0B) goto <D.29907>; else goto <D.29908>;
  <D.29907>:
  {
    struct MonoGenericContainer * container;

    container = klass->generic_container;
    D.29909 = container->type_argc;
    D.29910 = (unsigned int) D.29909;
    res = mono_array_new_specific (array_vtable, D.29910);
    i = 0;
    goto <D.21338>;
    <D.21337>:
    D.29911 = klass->image;
    D.29912 = container->type_params;
    i.223 = (unsigned int) i;
    D.29914 = i.223 * 32;
    D.29915 = D.29912 + D.29914;
    pklass = mono_class_from_generic_parameter (D.29915, D.29911, 0);
    {
      void * * __p;

      i.224 = (unsigned int) i;
      __p = mono_array_addr_with_size (res, 4, i.224);
      D.29917 = &pklass->byval_arg;
      D.29918 = mono_type_get_object (domain, D.29917);
      mono_gc_wbarrier_set_arrayref (res, __p, D.29918);
    }
    i = i + 1;
    <D.21338>:
    D.29909 = container->type_argc;
    D.29919 = (int) D.29909;
    if (D.29919 > i) goto <D.21337>; else goto <D.21339>;
    <D.21339>:
  }
  goto <D.29920>;
  <D.29908>:
  D.29921 = klass->generic_class;
  if (D.29921 != 0B) goto <D.29922>; else goto <D.29923>;
  <D.29922>:
  {
    struct MonoGenericInst * inst;

    D.29921 = klass->generic_class;
    inst = D.29921->context.class_inst;
    D.29924 = inst->type_argc;
    D.29925 = (unsigned int) D.29924;
    res = mono_array_new_specific (array_vtable, D.29925);
    i = 0;
    goto <D.21343>;
    <D.21342>:
    {
      void * * __p;

      i.224 = (unsigned int) i;
      __p = mono_array_addr_with_size (res, 4, i.224);
      D.29926 = inst->type_argv[i];
      D.29927 = mono_type_get_object (domain, D.29926);
      mono_gc_wbarrier_set_arrayref (res, __p, D.29927);
    }
    i = i + 1;
    <D.21343>:
    D.29924 = inst->type_argc;
    D.29928 = (int) D.29924;
    if (D.29928 > i) goto <D.21342>; else goto <D.21344>;
    <D.21344>:
  }
  goto <D.29929>;
  <D.29923>:
  res = mono_array_new_specific (array_vtable, 0);
  <D.29929>:
  <D.29920>:
  D.29930 = res;
  return D.29930;
}


ves_icall_Type_GetFields_internal (struct MonoReflectionType * type, guint32 bflags, struct MonoReflectionType * reftype)
{
  struct MonoVTable * D.29932;
  struct MonoType * D.29933;
  unsigned char D.29934;
  unsigned char D.29935;
  struct MonoArray * D.29938;
  struct MonoClass * D.29939;
  struct MonoType * D.29940;
  void * D.29941;
  unsigned char D.29942;
  int D.29945;
  void * * D.29948;
  struct MonoException * D.29949;
  unsigned int D.29950;
  int D.21822;
  int iftmp.225;
  int D.21821;
  const char[9] * D.29956;
  unsigned char D.29957;
  int D.29958;
  unsigned char D.29959;
  int D.29960;
  _Bool D.29961;
  _Bool D.29962;
  _Bool D.29963;
  const unsigned char * D.29966;
  unsigned char D.29967;
  int D.29968;
  const unsigned char * D.29969;
  unsigned char D.29970;
  int D.29971;
  _Bool D.29972;
  _Bool D.29973;
  const unsigned char * D.29976;
  unsigned char D.29977;
  int D.29978;
  const unsigned char * D.29979;
  unsigned char D.29980;
  int D.29981;
  _Bool D.29982;
  _Bool D.29983;
  const unsigned char * D.29986;
  unsigned char D.29987;
  int D.29988;
  const unsigned char * D.29989;
  unsigned char D.29990;
  int D.29991;
  const char * D.29993;
  unsigned int D.29996;
  unsigned int D.29999;
  unsigned int D.30006;
  unsigned int D.30011;
  unsigned int D.30014;
  unsigned int D.30019;
  unsigned int D.30022;
  int D.30027;
  int D.30030;
  void * D.30031;
  unsigned int D.30032;
  unsigned int D.30033;
  unsigned int D.30034;
  int D.30037;
  int D.30038;
  unsigned int D.30039;
  unsigned int D.30040;
  void * * D.30041;
  unsigned int D.30042;
  unsigned int D.30046;
  struct MonoClass * D.21828;
  struct MonoClass * tmp_klass.226;
  struct MonoClass * tmp_klass.227;
  _Bool D.30051;
  long int D.30052;
  long int D.30053;
  struct MonoVTable * D.30056;
  unsigned int i.228;
  unsigned int i.229;
  unsigned int D.30059;
  void * * D.30060;
  void * D.30061;
  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.29932 = MEM[(struct MonoObject *)type].vtable;
      domain = D.29932->domain;
      D.29933 = type->type;
      D.29934 = BIT_FIELD_REF <*D.29933, 8, 56>;
      D.29935 = D.29934 & 64;
      if (D.29935 != 0) goto <D.29936>; else goto <D.29937>;
      <D.29936>:
      D.29939 = mono_defaults.field_info_class;
      D.29938 = mono_array_new (domain, D.29939, 0);
      return D.29938;
      <D.29937>:
      D.29933 = type->type;
      startklass = mono_class_from_mono_type (D.29933);
      klass = startklass;
      D.29940 = reftype->type;
      refklass = mono_class_from_mono_type (D.29940);
      tmp_array.size = 0;
      tmp_array.capacity = 16;
      D.29941 = __builtin_alloca (64);
      tmp_array.data = D.29941;
      handle_parent:
      D.29942 = klass->exception_type;
      if (D.29942 != 0) goto <D.29943>; else goto <D.29944>;
      <D.29943>:
      D.29945 = tmp_array.capacity;
      if (D.29945 > 16) goto <D.29946>; else goto <D.29947>;
      <D.29946>:
      D.29948 = tmp_array.data;
      mono_gc_free_fixed (D.29948);
      <D.29947>:
      D.29949 = mono_class_get_exception_for_failure (klass);
      mono_raise_exception (D.29949);
      <D.29944>:
      iter = 0B;
      goto <D.21823>;
      <D.21825>:
      {
        guint32 flags;

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

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

            __s2 = mono_field_get_name (field);
            D.29956 = "_Deleted";
            D.29957 = MEM[(const unsigned char *)D.29956];
            D.29958 = (int) D.29957;
            D.29959 = *__s2;
            D.29960 = (int) D.29959;
            __result = D.29958 - D.29960;
            {
              D.29961 = __s2_len != 0;
              D.29962 = __result == 0;
              D.29963 = D.29961 & D.29962;
              if (D.29963 != 0) goto <D.29964>; else goto <D.29965>;
              <D.29964>:
              D.29966 = &MEM[(void *)"_Deleted" + 1B];
              D.29967 = *D.29966;
              D.29968 = (int) D.29967;
              D.29969 = __s2 + 1;
              D.29970 = *D.29969;
              D.29971 = (int) D.29970;
              __result = D.29968 - D.29971;
              D.29972 = __s2_len > 1;
              D.29962 = __result == 0;
              D.29973 = D.29972 & D.29962;
              if (D.29973 != 0) goto <D.29974>; else goto <D.29975>;
              <D.29974>:
              D.29976 = &MEM[(void *)"_Deleted" + 2B];
              D.29977 = *D.29976;
              D.29978 = (int) D.29977;
              D.29979 = __s2 + 2;
              D.29980 = *D.29979;
              D.29981 = (int) D.29980;
              __result = D.29978 - D.29981;
              D.29982 = __s2_len > 2;
              D.29962 = __result == 0;
              D.29983 = D.29982 & D.29962;
              if (D.29983 != 0) goto <D.29984>; else goto <D.29985>;
              <D.29984>:
              D.29986 = &MEM[(void *)"_Deleted" + 3B];
              D.29987 = *D.29986;
              D.29988 = (int) D.29987;
              D.29989 = __s2 + 3;
              D.29990 = *D.29989;
              D.29991 = (int) D.29990;
              __result = D.29988 - D.29991;
              <D.29985>:
              <D.29975>:
              <D.29965>:
            }
            D.21821 = __result;
          }
          iftmp.225 = -D.21821;
          goto <D.29992>;
          <D.29955>:
          D.29993 = mono_field_get_name (field);
          iftmp.225 = __builtin_strcmp (D.29993, "_Deleted");
          <D.29992>:
          D.21822 = iftmp.225;
        }
        if (D.21822 == 0) goto <D.29994>; else goto <D.29995>;
        <D.29994>:
        // predicted unlikely by continue predictor.
        goto <D.21823>;
        <D.29995>:
        <D.29952>:
        D.29996 = flags & 7;
        if (D.29996 == 6) goto <D.29997>; else goto <D.29998>;
        <D.29997>:
        D.29999 = bflags & 16;
        if (D.29999 != 0) goto <D.30000>; else goto <D.30001>;
        <D.30000>:
        match = match + 1;
        <D.30001>:
        goto <D.30002>;
        <D.29998>:
        if (klass == startklass) goto <D.30003>; else goto <D.30005>;
        <D.30005>:
        D.29996 = flags & 7;
        if (D.29996 != 1) goto <D.30003>; else goto <D.30004>;
        <D.30003>:
        D.30006 = bflags & 32;
        if (D.30006 != 0) goto <D.30007>; else goto <D.30008>;
        <D.30007>:
        match = match + 1;
        <D.30008>:
        <D.30004>:
        <D.30002>:
        if (match == 0) goto <D.30009>; else goto <D.30010>;
        <D.30009>:
        // predicted unlikely by continue predictor.
        goto <D.21823>;
        <D.30010>:
        match = 0;
        D.30011 = flags & 16;
        if (D.30011 != 0) goto <D.30012>; else goto <D.30013>;
        <D.30012>:
        D.30014 = bflags & 8;
        if (D.30014 != 0) goto <D.30015>; else goto <D.30016>;
        <D.30015>:
        D.30019 = bflags & 64;
        if (D.30019 != 0) goto <D.30017>; else goto <D.30020>;
        <D.30020>:
        if (klass == startklass) goto <D.30017>; else goto <D.30018>;
        <D.30017>:
        match = match + 1;
        <D.30018>:
        <D.30016>:
        goto <D.30021>;
        <D.30013>:
        D.30022 = bflags & 4;
        if (D.30022 != 0) goto <D.30023>; else goto <D.30024>;
        <D.30023>:
        match = match + 1;
        <D.30024>:
        <D.30021>:
        if (match == 0) goto <D.30025>; else goto <D.30026>;
        <D.30025>:
        // predicted unlikely by continue predictor.
        goto <D.21823>;
        <D.30026>:
        member = mono_field_get_object (domain, refklass, field);
        D.30027 = tmp_array.size;
        D.29945 = tmp_array.capacity;
        if (D.30027 >= D.29945) goto <D.30028>; else goto <D.30029>;
        <D.30028>:
        {
          void * __tmp;

          D.29945 = tmp_array.capacity;
          D.30030 = D.29945 * 2;
          D.30031 = mono_gc_make_root_descr_all_refs (D.30030);
          D.29945 = tmp_array.capacity;
          D.30032 = (unsigned int) D.29945;
          D.30033 = D.30032 * 8;
          __tmp = mono_gc_alloc_fixed (D.30033, D.30031);
          D.29945 = tmp_array.capacity;
          D.30032 = (unsigned int) D.29945;
          D.30034 = D.30032 * 4;
          D.29948 = tmp_array.data;
          mono_gc_memmove_aligned (__tmp, D.29948, D.30034);
          D.29945 = tmp_array.capacity;
          if (D.29945 > 16) goto <D.30035>; else goto <D.30036>;
          <D.30035>:
          D.29948 = tmp_array.data;
          mono_gc_free_fixed (D.29948);
          <D.30036>:
          tmp_array.data = __tmp;
          D.29945 = tmp_array.capacity;
          D.30030 = D.29945 * 2;
          tmp_array.capacity = D.30030;
        }
        <D.30029>:
        D.29948 = tmp_array.data;
        D.30027 = tmp_array.size;
        D.30037 = D.30027;
        D.30038 = D.30037 + 1;
        tmp_array.size = D.30038;
        D.30039 = (unsigned int) D.30037;
        D.30040 = D.30039 * 4;
        D.30041 = D.29948 + D.30040;
        *D.30041 = member;
      }
      <D.21823>:
      field = mono_class_get_fields_lazy (klass, &iter);
      if (field != 0B) goto <D.21825>; else goto <D.21826>;
      <D.21826>:
      D.30042 = bflags & 2;
      if (D.30042 == 0) goto <D.30043>; else goto <D.30044>;
      <D.30043>:
      klass = klass->parent;
      if (klass != 0B) goto handle_parent; else goto <D.30045>;
      <D.30045>:
      <D.30044>:
      D.30027 = tmp_array.size;
      D.30046 = (unsigned int) D.30027;
      {
        static struct MonoClass * tmp_klass;

        {
          tmp_klass.226 = tmp_klass;
          if (tmp_klass.226 == 0B) goto <D.30048>; else goto <D.30049>;
          <D.30048>:
          D.29939 = mono_defaults.field_info_class;
          tmp_klass.227 = mono_array_class_get (D.29939, 1);
          tmp_klass = tmp_klass.227;
          tmp_klass.226 = tmp_klass;
          D.30051 = tmp_klass.226 == 0B;
          D.30052 = (long int) D.30051;
          D.30053 = __builtin_expect (D.30052, 0);
          if (D.30053 != 0) goto <D.30054>; else goto <D.30055>;
          <D.30054>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "icall.c", 3414, "tmp_klass");
          <D.30055>:
          <D.30049>:
        }
        D.21828 = tmp_klass;
      }
      D.30056 = mono_class_vtable (domain, D.21828);
      res = mono_array_new_specific (D.30056, D.30046);
      i = 0;
      goto <D.21831>;
      <D.21830>:
      {
        void * * __p;

        i.228 = (unsigned int) i;
        __p = mono_array_addr_with_size (res, 4, i.228);
        D.29948 = tmp_array.data;
        i.229 = (unsigned int) i;
        D.30059 = i.229 * 4;
        D.30060 = D.29948 + D.30059;
        D.30061 = *D.30060;
        mono_gc_wbarrier_set_arrayref (res, __p, D.30061);
      }
      i = i + 1;
      <D.21831>:
      D.30027 = tmp_array.size;
      if (D.30027 > i) goto <D.21830>; else goto <D.21832>;
      <D.21832>:
      D.29945 = tmp_array.capacity;
      if (D.29945 > 16) goto <D.30062>; else goto <D.30063>;
      <D.30062>:
      D.29948 = tmp_array.data;
      mono_gc_free_fixed (D.29948);
      <D.30063>:
      D.29938 = res;
      return D.29938;
    }
  finally
    {
      iter = {CLOBBER};
      tmp_array = {CLOBBER};
    }
}


ves_icall_Type_GetField (struct MonoReflectionType * type, struct MonoString * name, guint32 bflags)
{
  struct MonoVTable * D.30066;
  struct MonoType * D.30067;
  struct MonoException * D.30070;
  unsigned char D.30071;
  unsigned char D.30072;
  struct MonoReflectionField * D.30075;
  int (*<T3926>) (const char *, const char *) iftmp.230;
  unsigned int D.30077;
  unsigned char D.30081;
  struct MonoException * D.30084;
  unsigned int D.30085;
  int D.21792;
  int iftmp.231;
  int D.21791;
  const char[9] * D.30091;
  unsigned char D.30092;
  int D.30093;
  unsigned char D.30094;
  int D.30095;
  _Bool D.30096;
  _Bool D.30097;
  _Bool D.30098;
  const unsigned char * D.30101;
  unsigned char D.30102;
  int D.30103;
  const unsigned char * D.30104;
  unsigned char D.30105;
  int D.30106;
  _Bool D.30107;
  _Bool D.30108;
  const unsigned char * D.30111;
  unsigned char D.30112;
  int D.30113;
  const unsigned char * D.30114;
  unsigned char D.30115;
  int D.30116;
  _Bool D.30117;
  _Bool D.30118;
  const unsigned char * D.30121;
  unsigned char D.30122;
  int D.30123;
  const unsigned char * D.30124;
  unsigned char D.30125;
  int D.30126;
  const char * D.30128;
  unsigned int D.30131;
  unsigned int D.30134;
  unsigned int D.30141;
  unsigned int D.30146;
  unsigned int D.30149;
  unsigned int D.30154;
  unsigned int D.30157;
  const char * D.30162;
  int D.30163;
  unsigned int D.30166;
  struct MonoDomain * domain;
  struct MonoClass * startklass;
  struct MonoClass * klass;
  int match;
  struct MonoClassField * field;
  void * iter;
  char * utf8_name;
  int (*<T3926>) (const char *, const char *) compare_func;
  void handle_parent = <<< error >>>;

  try
    {
      compare_func = 0B;
      D.30066 = MEM[(struct MonoObject *)type].vtable;
      domain = D.30066->domain;
      D.30067 = type->type;
      startklass = mono_class_from_mono_type (D.30067);
      klass = startklass;
      if (name == 0B) goto <D.30068>; else goto <D.30069>;
      <D.30068>:
      D.30070 = mono_get_exception_argument_null ("name");
      mono_raise_exception (D.30070);
      <D.30069>:
      D.30067 = type->type;
      D.30071 = BIT_FIELD_REF <*D.30067, 8, 56>;
      D.30072 = D.30071 & 64;
      if (D.30072 != 0) goto <D.30073>; else goto <D.30074>;
      <D.30073>:
      D.30075 = 0B;
      return D.30075;
      <D.30074>:
      D.30077 = bflags & 1;
      if (D.30077 != 0) goto <D.30078>; else goto <D.30079>;
      <D.30078>:
      iftmp.230 = monoeg_ascii_strcasecmp;
      goto <D.30080>;
      <D.30079>:
      iftmp.230 = strcmp;
      <D.30080>:
      compare_func = iftmp.230;
      handle_parent:
      D.30081 = klass->exception_type;
      if (D.30081 != 0) goto <D.30082>; else goto <D.30083>;
      <D.30082>:
      D.30084 = mono_class_get_exception_for_failure (klass);
      mono_raise_exception (D.30084);
      <D.30083>:
      iter = 0B;
      goto <D.21793>;
      <D.21794>:
      {
        guint32 flags;

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

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

            __s2 = mono_field_get_name (field);
            D.30091 = "_Deleted";
            D.30092 = MEM[(const unsigned char *)D.30091];
            D.30093 = (int) D.30092;
            D.30094 = *__s2;
            D.30095 = (int) D.30094;
            __result = D.30093 - D.30095;
            {
              D.30096 = __s2_len != 0;
              D.30097 = __result == 0;
              D.30098 = D.30096 & D.30097;
              if (D.30098 != 0) goto <D.30099>; else goto <D.30100>;
              <D.30099>:
              D.30101 = &MEM[(void *)"_Deleted" + 1B];
              D.30102 = *D.30101;
              D.30103 = (int) D.30102;
              D.30104 = __s2 + 1;
              D.30105 = *D.30104;
              D.30106 = (int) D.30105;
              __result = D.30103 - D.30106;
              D.30107 = __s2_len > 1;
              D.30097 = __result == 0;
              D.30108 = D.30107 & D.30097;
              if (D.30108 != 0) goto <D.30109>; else goto <D.30110>;
              <D.30109>:
              D.30111 = &MEM[(void *)"_Deleted" + 2B];
              D.30112 = *D.30111;
              D.30113 = (int) D.30112;
              D.30114 = __s2 + 2;
              D.30115 = *D.30114;
              D.30116 = (int) D.30115;
              __result = D.30113 - D.30116;
              D.30117 = __s2_len > 2;
              D.30097 = __result == 0;
              D.30118 = D.30117 & D.30097;
              if (D.30118 != 0) goto <D.30119>; else goto <D.30120>;
              <D.30119>:
              D.30121 = &MEM[(void *)"_Deleted" + 3B];
              D.30122 = *D.30121;
              D.30123 = (int) D.30122;
              D.30124 = __s2 + 3;
              D.30125 = *D.30124;
              D.30126 = (int) D.30125;
              __result = D.30123 - D.30126;
              <D.30120>:
              <D.30110>:
              <D.30100>:
            }
            D.21791 = __result;
          }
          iftmp.231 = -D.21791;
          goto <D.30127>;
          <D.30090>:
          D.30128 = mono_field_get_name (field);
          iftmp.231 = __builtin_strcmp (D.30128, "_Deleted");
          <D.30127>:
          D.21792 = iftmp.231;
        }
        if (D.21792 == 0) goto <D.30129>; else goto <D.30130>;
        <D.30129>:
        // predicted unlikely by continue predictor.
        goto <D.21793>;
        <D.30130>:
        <D.30087>:
        D.30131 = flags & 7;
        if (D.30131 == 6) goto <D.30132>; else goto <D.30133>;
        <D.30132>:
        D.30134 = bflags & 16;
        if (D.30134 != 0) goto <D.30135>; else goto <D.30136>;
        <D.30135>:
        match = match + 1;
        <D.30136>:
        goto <D.30137>;
        <D.30133>:
        if (klass == startklass) goto <D.30138>; else goto <D.30140>;
        <D.30140>:
        D.30131 = flags & 7;
        if (D.30131 != 1) goto <D.30138>; else goto <D.30139>;
        <D.30138>:
        D.30141 = bflags & 32;
        if (D.30141 != 0) goto <D.30142>; else goto <D.30143>;
        <D.30142>:
        match = match + 1;
        <D.30143>:
        <D.30139>:
        <D.30137>:
        if (match == 0) goto <D.30144>; else goto <D.30145>;
        <D.30144>:
        // predicted unlikely by continue predictor.
        goto <D.21793>;
        <D.30145>:
        match = 0;
        D.30146 = flags & 16;
        if (D.30146 != 0) goto <D.30147>; else goto <D.30148>;
        <D.30147>:
        D.30149 = bflags & 8;
        if (D.30149 != 0) goto <D.30150>; else goto <D.30151>;
        <D.30150>:
        D.30154 = bflags & 64;
        if (D.30154 != 0) goto <D.30152>; else goto <D.30155>;
        <D.30155>:
        if (klass == startklass) goto <D.30152>; else goto <D.30153>;
        <D.30152>:
        match = match + 1;
        <D.30153>:
        <D.30151>:
        goto <D.30156>;
        <D.30148>:
        D.30157 = bflags & 4;
        if (D.30157 != 0) goto <D.30158>; else goto <D.30159>;
        <D.30158>:
        match = match + 1;
        <D.30159>:
        <D.30156>:
        if (match == 0) goto <D.30160>; else goto <D.30161>;
        <D.30160>:
        // predicted unlikely by continue predictor.
        goto <D.21793>;
        <D.30161>:
        utf8_name = mono_string_to_utf8 (name);
        D.30162 = mono_field_get_name (field);
        D.30163 = compare_func (D.30162, utf8_name);
        if (D.30163 != 0) goto <D.30164>; else goto <D.30165>;
        <D.30164>:
        monoeg_g_free (utf8_name);
        // predicted unlikely by continue predictor.
        goto <D.21793>;
        <D.30165>:
        monoeg_g_free (utf8_name);
        D.30075 = mono_field_get_object (domain, klass, field);
        return D.30075;
      }
      <D.21793>:
      field = mono_class_get_fields_lazy (klass, &iter);
      if (field != 0B) goto <D.21794>; else goto <D.21795>;
      <D.21795>:
      D.30166 = bflags & 2;
      if (D.30166 == 0) goto <D.30167>; else goto <D.30168>;
      <D.30167>:
      klass = klass->parent;
      if (klass != 0B) goto handle_parent; else goto <D.30169>;
      <D.30169>:
      <D.30168>:
      D.30075 = 0B;
      return D.30075;
    }
  finally
    {
      iter = {CLOBBER};
    }
}


ves_icall_Type_GetEvents_internal (struct MonoReflectionType * type, guint32 bflags, struct MonoReflectionType * reftype)
{
  void * D.30172;
  struct MonoClass * System_Reflection_EventInfo.232;
  struct MonoImage * D.30176;
  struct MonoClass * System_Reflection_EventInfo.233;
  struct MonoVTable * D.30178;
  struct MonoType * D.30179;
  unsigned char D.30180;
  unsigned char D.30181;
  struct MonoArray * D.30184;
  struct MonoClass * D.22051;
  struct MonoClass * tmp_klass.234;
  struct MonoClass * tmp_klass.235;
  _Bool D.30189;
  long int D.30190;
  long int D.30191;
  struct MonoVTable * D.30194;
  unsigned char D.30195;
  struct MonoLoaderError * D.30197;
  short unsigned int D.30205;
  int D.30206;
  int D.30207;
  unsigned int D.30210;
  unsigned int D.30217;
  int D.30227;
  unsigned int D.30230;
  unsigned int D.30235;
  unsigned int D.30238;
  int D.30246;
  int D.30247;
  int D.30250;
  void * D.30251;
  unsigned int D.30252;
  unsigned int D.30253;
  unsigned int D.30254;
  void * * D.30255;
  int D.30258;
  int D.30259;
  unsigned int D.30260;
  unsigned int D.30261;
  void * * D.30262;
  struct MonoReflectionEvent * D.30263;
  unsigned int D.30264;
  unsigned int D.30268;
  struct MonoClass * D.22059;
  struct MonoClass * tmp_klass.236;
  struct MonoClass * tmp_klass.237;
  _Bool D.30273;
  long int D.30274;
  long int D.30275;
  struct MonoVTable * D.30278;
  unsigned int i.238;
  unsigned int i.239;
  unsigned int D.30281;
  void * * D.30282;
  void * D.30283;
  struct MonoLoaderError * D.30291;
  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.30172 = __builtin_alloca (64);
      tmp_array.data = D.30172;
      System_Reflection_EventInfo.232 = System_Reflection_EventInfo;
      if (System_Reflection_EventInfo.232 == 0B) goto <D.30174>; else goto <D.30175>;
      <D.30174>:
      D.30176 = mono_defaults.corlib;
      System_Reflection_EventInfo.233 = mono_class_from_name (D.30176, "System.Reflection", "EventInfo");
      System_Reflection_EventInfo = System_Reflection_EventInfo.233;
      <D.30175>:
      D.30178 = MEM[(struct MonoObject *)type].vtable;
      domain = D.30178->domain;
      D.30179 = type->type;
      D.30180 = BIT_FIELD_REF <*D.30179, 8, 56>;
      D.30181 = D.30180 & 64;
      if (D.30181 != 0) goto <D.30182>; else goto <D.30183>;
      <D.30182>:
      {
        static struct MonoClass * tmp_klass;

        {
          tmp_klass.234 = tmp_klass;
          if (tmp_klass.234 == 0B) goto <D.30186>; else goto <D.30187>;
          <D.30186>:
          System_Reflection_EventInfo.232 = System_Reflection_EventInfo;
          tmp_klass.235 = mono_array_class_get (System_Reflection_EventInfo.232, 1);
          tmp_klass = tmp_klass.235;
          tmp_klass.234 = tmp_klass;
          D.30189 = tmp_klass.234 == 0B;
          D.30190 = (long int) D.30189;
          D.30191 = __builtin_expect (D.30190, 0);
          if (D.30191 != 0) goto <D.30192>; else goto <D.30193>;
          <D.30192>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "icall.c", 3914, "tmp_klass");
          <D.30193>:
          <D.30187>:
        }
        D.22051 = tmp_klass;
      }
      D.30194 = mono_class_vtable (domain, D.22051);
      D.30184 = mono_array_new_specific (D.30194, 0);
      return D.30184;
      <D.30183>:
      D.30179 = type->type;
      startklass = mono_class_from_mono_type (D.30179);
      klass = startklass;
      handle_parent:
      mono_class_setup_vtable (klass);
      D.30195 = klass->exception_type;
      if (D.30195 != 0) goto loader_error; else goto <D.30196>;
      <D.30196>:
      D.30197 = mono_loader_get_last_error ();
      if (D.30197 != 0B) goto loader_error; else goto <D.30198>;
      <D.30198>:
      iter = 0B;
      goto <D.22054>;
      <D.22056>:
      match = 0;
      method = event->add;
      if (method == 0B) goto <D.30199>; else goto <D.30200>;
      <D.30199>:
      method = event->remove;
      <D.30200>:
      if (method == 0B) goto <D.30201>; else goto <D.30202>;
      <D.30201>:
      method = event->raise;
      <D.30202>:
      if (method != 0B) goto <D.30203>; else goto <D.30204>;
      <D.30203>:
      D.30205 = method->flags;
      D.30206 = (int) D.30205;
      D.30207 = D.30206 & 7;
      if (D.30207 == 6) goto <D.30208>; else goto <D.30209>;
      <D.30208>:
      D.30210 = bflags & 16;
      if (D.30210 != 0) goto <D.30211>; else goto <D.30212>;
      <D.30211>:
      match = match + 1;
      <D.30212>:
      goto <D.30213>;
      <D.30209>:
      if (klass == startklass) goto <D.30214>; else goto <D.30216>;
      <D.30216>:
      D.30205 = method->flags;
      D.30206 = (int) D.30205;
      D.30207 = D.30206 & 7;
      if (D.30207 != 1) goto <D.30214>; else goto <D.30215>;
      <D.30214>:
      D.30217 = bflags & 32;
      if (D.30217 != 0) goto <D.30218>; else goto <D.30219>;
      <D.30218>:
      match = match + 1;
      <D.30219>:
      <D.30215>:
      <D.30213>:
      goto <D.30220>;
      <D.30204>:
      D.30217 = bflags & 32;
      if (D.30217 != 0) goto <D.30221>; else goto <D.30222>;
      <D.30221>:
      match = match + 1;
      <D.30222>:
      <D.30220>:
      if (match == 0) goto <D.30223>; else goto <D.30224>;
      <D.30223>:
      // predicted unlikely by continue predictor.
      goto <D.22054>;
      <D.30224>:
      match = 0;
      if (method != 0B) goto <D.30225>; else goto <D.30226>;
      <D.30225>:
      D.30205 = method->flags;
      D.30206 = (int) D.30205;
      D.30227 = D.30206 & 16;
      if (D.30227 != 0) goto <D.30228>; else goto <D.30229>;
      <D.30228>:
      D.30230 = bflags & 8;
      if (D.30230 != 0) goto <D.30231>; else goto <D.30232>;
      <D.30231>:
      D.30235 = bflags & 64;
      if (D.30235 != 0) goto <D.30233>; else goto <D.30236>;
      <D.30236>:
      if (klass == startklass) goto <D.30233>; else goto <D.30234>;
      <D.30233>:
      match = match + 1;
      <D.30234>:
      <D.30232>:
      goto <D.30237>;
      <D.30229>:
      D.30238 = bflags & 4;
      if (D.30238 != 0) goto <D.30239>; else goto <D.30240>;
      <D.30239>:
      match = match + 1;
      <D.30240>:
      <D.30237>:
      goto <D.30241>;
      <D.30226>:
      D.30238 = bflags & 4;
      if (D.30238 != 0) goto <D.30242>; else goto <D.30243>;
      <D.30242>:
      match = match + 1;
      <D.30243>:
      <D.30241>:
      if (match == 0) goto <D.30244>; else goto <D.30245>;
      <D.30244>:
      // predicted unlikely by continue predictor.
      goto <D.22054>;
      <D.30245>:
      D.30246 = tmp_array.size;
      D.30247 = tmp_array.capacity;
      if (D.30246 >= D.30247) goto <D.30248>; else goto <D.30249>;
      <D.30248>:
      {
        void * __tmp;

        D.30247 = tmp_array.capacity;
        D.30250 = D.30247 * 2;
        D.30251 = mono_gc_make_root_descr_all_refs (D.30250);
        D.30247 = tmp_array.capacity;
        D.30252 = (unsigned int) D.30247;
        D.30253 = D.30252 * 8;
        __tmp = mono_gc_alloc_fixed (D.30253, D.30251);
        D.30247 = tmp_array.capacity;
        D.30252 = (unsigned int) D.30247;
        D.30254 = D.30252 * 4;
        D.30255 = tmp_array.data;
        mono_gc_memmove_aligned (__tmp, D.30255, D.30254);
        D.30247 = tmp_array.capacity;
        if (D.30247 > 16) goto <D.30256>; else goto <D.30257>;
        <D.30256>:
        D.30255 = tmp_array.data;
        mono_gc_free_fixed (D.30255);
        <D.30257>:
        tmp_array.data = __tmp;
        D.30247 = tmp_array.capacity;
        D.30250 = D.30247 * 2;
        tmp_array.capacity = D.30250;
      }
      <D.30249>:
      D.30255 = tmp_array.data;
      D.30246 = tmp_array.size;
      D.30258 = D.30246;
      D.30259 = D.30258 + 1;
      tmp_array.size = D.30259;
      D.30260 = (unsigned int) D.30258;
      D.30261 = D.30260 * 4;
      D.30262 = D.30255 + D.30261;
      D.30263 = mono_event_get_object (domain, startklass, event);
      *D.30262 = D.30263;
      <D.22054>:
      event = mono_class_get_events (klass, &iter);
      if (event != 0B) goto <D.22056>; else goto <D.22057>;
      <D.22057>:
      D.30264 = bflags & 2;
      if (D.30264 == 0) goto <D.30265>; else goto <D.30266>;
      <D.30265>:
      klass = klass->parent;
      if (klass != 0B) goto handle_parent; else goto <D.30267>;
      <D.30267>:
      <D.30266>:
      D.30246 = tmp_array.size;
      D.30268 = (unsigned int) D.30246;
      {
        static struct MonoClass * tmp_klass;

        {
          tmp_klass.236 = tmp_klass;
          if (tmp_klass.236 == 0B) goto <D.30270>; else goto <D.30271>;
          <D.30270>:
          System_Reflection_EventInfo.232 = System_Reflection_EventInfo;
          tmp_klass.237 = mono_array_class_get (System_Reflection_EventInfo.232, 1);
          tmp_klass = tmp_klass.237;
          tmp_klass.236 = tmp_klass;
          D.30273 = tmp_klass.236 == 0B;
          D.30274 = (long int) D.30273;
          D.30275 = __builtin_expect (D.30274, 0);
          if (D.30275 != 0) goto <D.30276>; else goto <D.30277>;
          <D.30276>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "icall.c", 3965, "tmp_klass");
          <D.30277>:
          <D.30271>:
        }
        D.22059 = tmp_klass;
      }
      D.30278 = mono_class_vtable (domain, D.22059);
      res = mono_array_new_specific (D.30278, D.30268);
      i = 0;
      goto <D.22062>;
      <D.22061>:
      {
        void * * __p;

        i.238 = (unsigned int) i;
        __p = mono_array_addr_with_size (res, 4, i.238);
        D.30255 = tmp_array.data;
        i.239 = (unsigned int) i;
        D.30281 = i.239 * 4;
        D.30282 = D.30255 + D.30281;
        D.30283 = *D.30282;
        mono_gc_wbarrier_set_arrayref (res, __p, D.30283);
      }
      i = i + 1;
      <D.22062>:
      D.30246 = tmp_array.size;
      if (D.30246 > i) goto <D.22061>; else goto <D.22063>;
      <D.22063>:
      D.30247 = tmp_array.capacity;
      if (D.30247 > 16) goto <D.30284>; else goto <D.30285>;
      <D.30284>:
      D.30255 = tmp_array.data;
      mono_gc_free_fixed (D.30255);
      <D.30285>:
      D.30184 = res;
      return D.30184;
      loader_error:
      D.30247 = tmp_array.capacity;
      if (D.30247 > 16) goto <D.30286>; else goto <D.30287>;
      <D.30286>:
      D.30255 = tmp_array.data;
      mono_gc_free_fixed (D.30255);
      <D.30287>:
      D.30195 = klass->exception_type;
      if (D.30195 != 0) goto <D.30288>; else goto <D.30289>;
      <D.30288>:
      ex = mono_class_get_exception_for_failure (klass);
      goto <D.30290>;
      <D.30289>:
      D.30291 = mono_loader_get_last_error ();
      ex = mono_loader_error_prepare_exception (D.30291);
      mono_loader_clear_error ();
      <D.30290>:
      mono_raise_exception (ex);
      D.30184 = 0B;
      return D.30184;
    }
  finally
    {
      iter = {CLOBBER};
      tmp_array = {CLOBBER};
    }
}


ves_icall_MonoType_GetElementType (struct MonoReflectionType * type)
{
  struct MonoType * D.30294;
  short unsigned int D.30295;
  short unsigned int D.30296;
  struct MonoReflectionType * D.30299;
  struct MonoClass * D.30300;
  struct MonoType * D.30301;
  struct MonoVTable * D.30302;
  struct MonoDomain * D.30303;
  unsigned char D.30304;
  unsigned char D.30305;
  struct MonoType * D.30308;
  struct MonoClass * D.30310;
  unsigned char D.30312;
  struct MonoType * D.30314;
  unsigned char D.30317;
  struct MonoClass * class;

  D.30294 = type->type;
  D.30295 = BIT_FIELD_REF <*D.30294, 16, 48>;
  D.30296 = D.30295 & 16639;
  if (D.30296 == 29) goto <D.30297>; else goto <D.30298>;
  <D.30297>:
  D.30294 = type->type;
  D.30300 = D.30294->data.klass;
  D.30301 = &D.30300->byval_arg;
  D.30302 = MEM[(struct MonoObject *)type].vtable;
  D.30303 = D.30302->domain;
  D.30299 = mono_type_get_object (D.30303, D.30301);
  return D.30299;
  <D.30298>:
  D.30294 = type->type;
  class = mono_class_from_mono_type (D.30294);
  mono_class_init_or_throw (class);
  D.30294 = type->type;
  D.30304 = BIT_FIELD_REF <*D.30294, 8, 56>;
  D.30305 = D.30304 & 64;
  if (D.30305 != 0) goto <D.30306>; else goto <D.30307>;
  <D.30306>:
  D.30308 = &class->byval_arg;
  D.30302 = MEM[(struct MonoObject *)type].vtable;
  D.30303 = D.30302->domain;
  D.30299 = mono_type_get_object (D.30303, D.30308);
  return D.30299;
  <D.30307>:
  D.30310 = class->element_class;
  if (D.30310 != 0B) goto <D.30311>; else goto <D.30309>;
  <D.30311>:
  D.30312 = class->rank;
  if (D.30312 != 0) goto <D.30313>; else goto <D.30309>;
  <D.30313>:
  D.30310 = class->element_class;
  D.30314 = &D.30310->byval_arg;
  D.30302 = MEM[(struct MonoObject *)type].vtable;
  D.30303 = D.30302->domain;
  D.30299 = mono_type_get_object (D.30303, D.30314);
  return D.30299;
  <D.30309>:
  D.30310 = class->element_class;
  if (D.30310 != 0B) goto <D.30316>; else goto <D.30315>;
  <D.30316>:
  D.30294 = type->type;
  D.30317 = D.30294->type;
  if (D.30317 == 15) goto <D.30318>; else goto <D.30315>;
  <D.30318>:
  D.30310 = class->element_class;
  D.30314 = &D.30310->byval_arg;
  D.30302 = MEM[(struct MonoObject *)type].vtable;
  D.30303 = D.30302->domain;
  D.30299 = mono_type_get_object (D.30303, D.30314);
  return D.30299;
  <D.30315>:
  D.30299 = 0B;
  return D.30299;
}


ves_icall_MonoType_GetCorrespondingInflatedMethod (struct MonoReflectionType * type, struct MonoReflectionMethod * generic)
{
  struct MonoVTable * D.30320;
  struct MonoType * D.30321;
  unsigned int D.30322;
  struct MonoMethod * D.30323;
  unsigned int D.30324;
  struct MonoReflectionMethod * D.30327;
  struct MonoDomain * domain;
  struct MonoClass * klass;
  struct MonoMethod * method;
  void * iter;

  try
    {
      D.30320 = MEM[(struct MonoObject *)type].vtable;
      domain = D.30320->domain;
      D.30321 = type->type;
      klass = mono_class_from_mono_type (D.30321);
      mono_class_init_or_throw (klass);
      iter = 0B;
      goto <D.21417>;
      <D.21416>:
      D.30322 = method->token;
      D.30323 = generic->method;
      D.30324 = D.30323->token;
      if (D.30322 == D.30324) goto <D.30325>; else goto <D.30326>;
      <D.30325>:
      D.30327 = mono_method_get_object (domain, method, klass);
      return D.30327;
      <D.30326>:
      <D.21417>:
      method = mono_class_get_methods (klass, &iter);
      if (method != 0B) goto <D.21416>; else goto <D.21418>;
      <D.21418>:
      D.30327 = 0B;
      return D.30327;
    }
  finally
    {
      iter = {CLOBBER};
    }
}


ves_icall_Type_GetConstructors_internal (struct MonoReflectionType * type, guint32 bflags, struct MonoReflectionType * reftype)
{
  void * D.30330;
  struct MonoVTable * D.30331;
  struct MonoType * D.30332;
  unsigned char D.30333;
  unsigned char D.30334;
  struct MonoArray * D.30337;
  struct MonoClass * D.21934;
  struct MonoClass * tmp_klass.240;
  struct MonoClass * D.30341;
  struct MonoClass * tmp_klass.241;
  _Bool D.30343;
  long int D.30344;
  long int D.30345;
  struct MonoVTable * D.30348;
  struct MonoType * D.30349;
  struct MonoClass * System_Reflection_ConstructorInfo.242;
  struct MonoImage * D.30353;
  struct MonoClass * System_Reflection_ConstructorInfo.243;
  int D.21943;
  int iftmp.244;
  int D.21942;
  const char[6] * D.30358;
  unsigned char D.30359;
  int D.30360;
  unsigned char D.30361;
  int D.30362;
  _Bool D.30363;
  _Bool D.30364;
  _Bool D.30365;
  const unsigned char * D.30368;
  unsigned char D.30369;
  int D.30370;
  const unsigned char * D.30371;
  unsigned char D.30372;
  int D.30373;
  _Bool D.30374;
  _Bool D.30375;
  const unsigned char * D.30378;
  unsigned char D.30379;
  int D.30380;
  const unsigned char * D.30381;
  unsigned char D.30382;
  int D.30383;
  _Bool D.30384;
  _Bool D.30385;
  const unsigned char * D.30388;
  unsigned char D.30389;
  int D.30390;
  const unsigned char * D.30391;
  unsigned char D.30392;
  int D.30393;
  const char * D.30395;
  int D.21952;
  int iftmp.245;
  int D.21951;
  const char[7] * D.30401;
  unsigned char D.30402;
  int D.30403;
  unsigned char D.30404;
  int D.30405;
  _Bool D.30406;
  _Bool D.30407;
  _Bool D.30408;
  const unsigned char * D.30411;
  unsigned char D.30412;
  int D.30413;
  const unsigned char * D.30414;
  unsigned char D.30415;
  int D.30416;
  _Bool D.30417;
  _Bool D.30418;
  const unsigned char * D.30421;
  unsigned char D.30422;
  int D.30423;
  const unsigned char * D.30424;
  unsigned char D.30425;
  int D.30426;
  _Bool D.30427;
  _Bool D.30428;
  const unsigned char * D.30431;
  unsigned char D.30432;
  int D.30433;
  const unsigned char * D.30434;
  unsigned char D.30435;
  int D.30436;
  short unsigned int D.30440;
  int D.30441;
  int D.30442;
  unsigned int D.30445;
  unsigned int D.30449;
  int D.30454;
  unsigned int D.30457;
  unsigned int D.30462;
  unsigned int D.30465;
  int D.30470;
  int D.30471;
  int D.30474;
  void * D.30475;
  unsigned int D.30476;
  unsigned int D.30477;
  unsigned int D.30478;
  void * * D.30479;
  int D.30482;
  int D.30483;
  unsigned int D.30484;
  unsigned int D.30485;
  void * * D.30486;
  unsigned int D.30487;
  struct MonoClass * D.21958;
  struct MonoClass * tmp_klass.246;
  struct MonoClass * tmp_klass.247;
  _Bool D.30492;
  long int D.30493;
  long int D.30494;
  struct MonoVTable * D.30497;
  unsigned int i.248;
  unsigned int i.249;
  unsigned int D.30500;
  void * * D.30501;
  void * D.30502;
  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.30330 = __builtin_alloca (64);
      tmp_array.data = D.30330;
      D.30331 = MEM[(struct MonoObject *)type].vtable;
      domain = D.30331->domain;
      D.30332 = type->type;
      D.30333 = BIT_FIELD_REF <*D.30332, 8, 56>;
      D.30334 = D.30333 & 64;
      if (D.30334 != 0) goto <D.30335>; else goto <D.30336>;
      <D.30335>:
      {
        static struct MonoClass * tmp_klass;

        {
          tmp_klass.240 = tmp_klass;
          if (tmp_klass.240 == 0B) goto <D.30339>; else goto <D.30340>;
          <D.30339>:
          D.30341 = mono_defaults.method_info_class;
          tmp_klass.241 = mono_array_class_get (D.30341, 1);
          tmp_klass = tmp_klass.241;
          tmp_klass.240 = tmp_klass;
          D.30343 = tmp_klass.240 == 0B;
          D.30344 = (long int) D.30343;
          D.30345 = __builtin_expect (D.30344, 0);
          if (D.30345 != 0) goto <D.30346>; else goto <D.30347>;
          <D.30346>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "icall.c", 3617, "tmp_klass");
          <D.30347>:
          <D.30340>:
        }
        D.21934 = tmp_klass;
      }
      D.30348 = mono_class_vtable (domain, D.21934);
      D.30337 = mono_array_new_specific (D.30348, 0);
      return D.30337;
      <D.30336>:
      D.30332 = type->type;
      startklass = mono_class_from_mono_type (D.30332);
      klass = startklass;
      D.30349 = reftype->type;
      refklass = mono_class_from_mono_type (D.30349);
      System_Reflection_ConstructorInfo.242 = System_Reflection_ConstructorInfo;
      if (System_Reflection_ConstructorInfo.242 == 0B) goto <D.30351>; else goto <D.30352>;
      <D.30351>:
      D.30353 = mono_defaults.corlib;
      System_Reflection_ConstructorInfo.243 = mono_class_from_name (D.30353, "System.Reflection", "ConstructorInfo");
      System_Reflection_ConstructorInfo = System_Reflection_ConstructorInfo.243;
      <D.30352>:
      iter = 0B;
      goto <D.21953>;
      <D.21955>:
      match = 0;
      {
        size_t __s1_len;
        size_t __s2_len;

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

          __s2 = method->name;
          D.30358 = ".ctor";
          D.30359 = MEM[(const unsigned char *)D.30358];
          D.30360 = (int) D.30359;
          D.30361 = *__s2;
          D.30362 = (int) D.30361;
          __result = D.30360 - D.30362;
          {
            D.30363 = __s2_len != 0;
            D.30364 = __result == 0;
            D.30365 = D.30363 & D.30364;
            if (D.30365 != 0) goto <D.30366>; else goto <D.30367>;
            <D.30366>:
            D.30368 = &MEM[(void *)".ctor" + 1B];
            D.30369 = *D.30368;
            D.30370 = (int) D.30369;
            D.30371 = __s2 + 1;
            D.30372 = *D.30371;
            D.30373 = (int) D.30372;
            __result = D.30370 - D.30373;
            D.30374 = __s2_len > 1;
            D.30364 = __result == 0;
            D.30375 = D.30374 & D.30364;
            if (D.30375 != 0) goto <D.30376>; else goto <D.30377>;
            <D.30376>:
            D.30378 = &MEM[(void *)".ctor" + 2B];
            D.30379 = *D.30378;
            D.30380 = (int) D.30379;
            D.30381 = __s2 + 2;
            D.30382 = *D.30381;
            D.30383 = (int) D.30382;
            __result = D.30380 - D.30383;
            D.30384 = __s2_len > 2;
            D.30364 = __result == 0;
            D.30385 = D.30384 & D.30364;
            if (D.30385 != 0) goto <D.30386>; else goto <D.30387>;
            <D.30386>:
            D.30388 = &MEM[(void *)".ctor" + 3B];
            D.30389 = *D.30388;
            D.30390 = (int) D.30389;
            D.30391 = __s2 + 3;
            D.30392 = *D.30391;
            D.30393 = (int) D.30392;
            __result = D.30390 - D.30393;
            <D.30387>:
            <D.30377>:
            <D.30367>:
          }
          D.21942 = __result;
        }
        iftmp.244 = -D.21942;
        goto <D.30394>;
        <D.30357>:
        D.30395 = method->name;
        iftmp.244 = __builtin_strcmp (D.30395, ".ctor");
        <D.30394>:
        D.21943 = iftmp.244;
      }
      if (D.21943 != 0) goto <D.30396>; else goto <D.30397>;
      <D.30396>:
      {
        size_t __s1_len;
        size_t __s2_len;

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

          __s2 = method->name;
          D.30401 = ".cctor";
          D.30402 = MEM[(const unsigned char *)D.30401];
          D.30403 = (int) D.30402;
          D.30404 = *__s2;
          D.30405 = (int) D.30404;
          __result = D.30403 - D.30405;
          {
            D.30406 = __s2_len != 0;
            D.30407 = __result == 0;
            D.30408 = D.30406 & D.30407;
            if (D.30408 != 0) goto <D.30409>; else goto <D.30410>;
            <D.30409>:
            D.30411 = &MEM[(void *)".cctor" + 1B];
            D.30412 = *D.30411;
            D.30413 = (int) D.30412;
            D.30414 = __s2 + 1;
            D.30415 = *D.30414;
            D.30416 = (int) D.30415;
            __result = D.30413 - D.30416;
            D.30417 = __s2_len > 1;
            D.30407 = __result == 0;
            D.30418 = D.30417 & D.30407;
            if (D.30418 != 0) goto <D.30419>; else goto <D.30420>;
            <D.30419>:
            D.30421 = &MEM[(void *)".cctor" + 2B];
            D.30422 = *D.30421;
            D.30423 = (int) D.30422;
            D.30424 = __s2 + 2;
            D.30425 = *D.30424;
            D.30426 = (int) D.30425;
            __result = D.30423 - D.30426;
            D.30427 = __s2_len > 2;
            D.30407 = __result == 0;
            D.30428 = D.30427 & D.30407;
            if (D.30428 != 0) goto <D.30429>; else goto <D.30430>;
            <D.30429>:
            D.30431 = &MEM[(void *)".cctor" + 3B];
            D.30432 = *D.30431;
            D.30433 = (int) D.30432;
            D.30434 = __s2 + 3;
            D.30435 = *D.30434;
            D.30436 = (int) D.30435;
            __result = D.30433 - D.30436;
            <D.30430>:
            <D.30420>:
            <D.30410>:
          }
          D.21951 = __result;
        }
        iftmp.245 = -D.21951;
        goto <D.30437>;
        <D.30400>:
        D.30395 = method->name;
        iftmp.245 = __builtin_strcmp (D.30395, ".cctor");
        <D.30437>:
        D.21952 = iftmp.245;
      }
      if (D.21952 != 0) goto <D.30438>; else goto <D.30439>;
      <D.30438>:
      // predicted unlikely by continue predictor.
      goto <D.21953>;
      <D.30439>:
      <D.30397>:
      D.30440 = method->flags;
      D.30441 = (int) D.30440;
      D.30442 = D.30441 & 7;
      if (D.30442 == 6) goto <D.30443>; else goto <D.30444>;
      <D.30443>:
      D.30445 = bflags & 16;
      if (D.30445 != 0) goto <D.30446>; else goto <D.30447>;
      <D.30446>:
      match = match + 1;
      <D.30447>:
      goto <D.30448>;
      <D.30444>:
      D.30449 = bflags & 32;
      if (D.30449 != 0) goto <D.30450>; else goto <D.30451>;
      <D.30450>:
      match = match + 1;
      <D.30451>:
      <D.30448>:
      if (match == 0) goto <D.30452>; else goto <D.30453>;
      <D.30452>:
      // predicted unlikely by continue predictor.
      goto <D.21953>;
      <D.30453>:
      match = 0;
      D.30440 = method->flags;
      D.30441 = (int) D.30440;
      D.30454 = D.30441 & 16;
      if (D.30454 != 0) goto <D.30455>; else goto <D.30456>;
      <D.30455>:
      D.30457 = bflags & 8;
      if (D.30457 != 0) goto <D.30458>; else goto <D.30459>;
      <D.30458>:
      D.30462 = bflags & 64;
      if (D.30462 != 0) goto <D.30460>; else goto <D.30463>;
      <D.30463>:
      if (klass == startklass) goto <D.30460>; else goto <D.30461>;
      <D.30460>:
      match = match + 1;
      <D.30461>:
      <D.30459>:
      goto <D.30464>;
      <D.30456>:
      D.30465 = bflags & 4;
      if (D.30465 != 0) goto <D.30466>; else goto <D.30467>;
      <D.30466>:
      match = match + 1;
      <D.30467>:
      <D.30464>:
      if (match == 0) goto <D.30468>; else goto <D.30469>;
      <D.30468>:
      // predicted unlikely by continue predictor.
      goto <D.21953>;
      <D.30469>:
      member = mono_method_get_object (domain, method, refklass);
      D.30470 = tmp_array.size;
      D.30471 = tmp_array.capacity;
      if (D.30470 >= D.30471) goto <D.30472>; else goto <D.30473>;
      <D.30472>:
      {
        void * __tmp;

        D.30471 = tmp_array.capacity;
        D.30474 = D.30471 * 2;
        D.30475 = mono_gc_make_root_descr_all_refs (D.30474);
        D.30471 = tmp_array.capacity;
        D.30476 = (unsigned int) D.30471;
        D.30477 = D.30476 * 8;
        __tmp = mono_gc_alloc_fixed (D.30477, D.30475);
        D.30471 = tmp_array.capacity;
        D.30476 = (unsigned int) D.30471;
        D.30478 = D.30476 * 4;
        D.30479 = tmp_array.data;
        mono_gc_memmove_aligned (__tmp, D.30479, D.30478);
        D.30471 = tmp_array.capacity;
        if (D.30471 > 16) goto <D.30480>; else goto <D.30481>;
        <D.30480>:
        D.30479 = tmp_array.data;
        mono_gc_free_fixed (D.30479);
        <D.30481>:
        tmp_array.data = __tmp;
        D.30471 = tmp_array.capacity;
        D.30474 = D.30471 * 2;
        tmp_array.capacity = D.30474;
      }
      <D.30473>:
      D.30479 = tmp_array.data;
      D.30470 = tmp_array.size;
      D.30482 = D.30470;
      D.30483 = D.30482 + 1;
      tmp_array.size = D.30483;
      D.30484 = (unsigned int) D.30482;
      D.30485 = D.30484 * 4;
      D.30486 = D.30479 + D.30485;
      *D.30486 = member;
      <D.21953>:
      method = mono_class_get_methods (klass, &iter);
      if (method != 0B) goto <D.21955>; else goto <D.21956>;
      <D.21956>:
      D.30470 = tmp_array.size;
      D.30487 = (unsigned int) D.30470;
      {
        static struct MonoClass * tmp_klass;

        {
          tmp_klass.246 = tmp_klass;
          if (tmp_klass.246 == 0B) goto <D.30489>; else goto <D.30490>;
          <D.30489>:
          System_Reflection_ConstructorInfo.242 = System_Reflection_ConstructorInfo;
          tmp_klass.247 = mono_array_class_get (System_Reflection_ConstructorInfo.242, 1);
          tmp_klass = tmp_klass.247;
          tmp_klass.246 = tmp_klass;
          D.30492 = tmp_klass.246 == 0B;
          D.30493 = (long int) D.30492;
          D.30494 = __builtin_expect (D.30493, 0);
          if (D.30494 != 0) goto <D.30495>; else goto <D.30496>;
          <D.30495>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "icall.c", 3656, "tmp_klass");
          <D.30496>:
          <D.30490>:
        }
        D.21958 = tmp_klass;
      }
      D.30497 = mono_class_vtable (domain, D.21958);
      res = mono_array_new_specific (D.30497, D.30487);
      i = 0;
      goto <D.21961>;
      <D.21960>:
      {
        void * * __p;

        i.248 = (unsigned int) i;
        __p = mono_array_addr_with_size (res, 4, i.248);
        D.30479 = tmp_array.data;
        i.249 = (unsigned int) i;
        D.30500 = i.249 * 4;
        D.30501 = D.30479 + D.30500;
        D.30502 = *D.30501;
        mono_gc_wbarrier_set_arrayref (res, __p, D.30502);
      }
      i = i + 1;
      <D.21961>:
      D.30470 = tmp_array.size;
      if (D.30470 > i) goto <D.21960>; else goto <D.21962>;
      <D.21962>:
      D.30471 = tmp_array.capacity;
      if (D.30471 > 16) goto <D.30503>; else goto <D.30504>;
      <D.30503>:
      D.30479 = tmp_array.data;
      mono_gc_free_fixed (D.30479);
      <D.30504>:
      D.30337 = res;
      return D.30337;
    }
  finally
    {
      iter = {CLOBBER};
      tmp_array = {CLOBBER};
    }
}


ves_icall_MonoType_GetArrayRank (struct MonoReflectionType * type)
{
  struct MonoType * D.30507;
  unsigned char D.30508;
  _Bool D.30509;
  _Bool D.30510;
  _Bool D.30511;
  struct MonoException * D.30514;
  gint32 D.30515;
  unsigned char D.30516;
  struct MonoClass * class;

  D.30507 = type->type;
  D.30508 = D.30507->type;
  D.30509 = D.30508 != 20;
  D.30510 = D.30508 != 29;
  D.30511 = D.30509 & D.30510;
  if (D.30511 != 0) goto <D.30512>; else goto <D.30513>;
  <D.30512>:
  D.30514 = mono_get_exception_argument ("type", "Type must be an array type");
  mono_raise_exception (D.30514);
  <D.30513>:
  D.30507 = type->type;
  class = mono_class_from_mono_type (D.30507);
  D.30516 = class->rank;
  D.30515 = (gint32) D.30516;
  return D.30515;
}


ves_icall_get_enum_info (struct MonoReflectionType * type, struct MonoEnumInfo * info)
{
  struct MonoVTable * D.30518;
  struct MonoType * D.30519;
  struct MonoType * D.30520;
  struct MonoReflectionType * D.30521;
  struct MonoReflectionType * * D.30522;
  guint iftmp.250;
  int D.30524;
  int D.30527;
  int D.30528;
  struct MonoClass * D.30530;
  struct MonoArray * D.30531;
  struct MonoArray * * D.30532;
  struct MonoArray * D.30533;
  struct MonoArray * * D.30534;
  struct MonoType * D.30535;
  short unsigned int D.30536;
  int D.30537;
  int D.30538;
  int D.21721;
  int iftmp.251;
  int D.21717;
  const char[8] * D.30544;
  unsigned char D.30545;
  int D.30546;
  unsigned char D.30547;
  int D.30548;
  _Bool D.30549;
  _Bool D.30550;
  _Bool D.30551;
  const unsigned char * D.30554;
  unsigned char D.30555;
  int D.30556;
  const unsigned char * D.30557;
  unsigned char D.30558;
  int D.30559;
  _Bool D.30560;
  _Bool D.30561;
  const unsigned char * D.30564;
  unsigned char D.30565;
  int D.30566;
  const unsigned char * D.30567;
  unsigned char D.30568;
  int D.30569;
  _Bool D.30570;
  _Bool D.30571;
  const unsigned char * D.30574;
  unsigned char D.30575;
  int D.30576;
  const unsigned char * D.30577;
  unsigned char D.30578;
  int D.30579;
  const char * D.30581;
  int D.30584;
  int D.21730;
  int iftmp.252;
  int D.21729;
  const char[9] * D.30590;
  unsigned char D.30591;
  int D.30592;
  unsigned char D.30593;
  int D.30594;
  _Bool D.30595;
  _Bool D.30596;
  _Bool D.30597;
  const unsigned char * D.30600;
  unsigned char D.30601;
  int D.30602;
  const unsigned char * D.30603;
  unsigned char D.30604;
  int D.30605;
  _Bool D.30606;
  _Bool D.30607;
  const unsigned char * D.30610;
  unsigned char D.30611;
  int D.30612;
  const unsigned char * D.30613;
  unsigned char D.30614;
  int D.30615;
  _Bool D.30616;
  _Bool D.30617;
  const unsigned char * D.30620;
  unsigned char D.30621;
  int D.30622;
  const unsigned char * D.30623;
  unsigned char D.30624;
  int D.30625;
  const char * D.30627;
  struct MonoArray * D.30630;
  const char * D.30631;
  struct MonoString * D.30632;
  const char * p.253;
  const char * p.254;
  unsigned int D.30635;
  struct MonoType * D.30636;
  unsigned char D.30637;
  int D.30638;
  struct MonoArray * D.30639;
  char D.30640;
  short unsigned int D.30641;
  short int D.30642;
  unsigned int D.30643;
  int D.30644;
  long long unsigned int D.30645;
  long long int D.30646;
  struct MonoType * D.30647;
  unsigned char D.30648;
  int D.30649;
  struct MonoDomain * domain;
  struct MonoClass * enumc;
  guint j;
  guint nvalues;
  guint crow;
  void * iter;
  struct MonoClassField * field;

  try
    {
      D.30518 = MEM[(struct MonoObject *)type].vtable;
      domain = D.30518->domain;
      D.30519 = type->type;
      enumc = mono_class_from_mono_type (D.30519);
      j = 0;
      mono_class_init_or_throw (enumc);
      D.30520 = mono_class_enum_basetype (enumc);
      D.30521 = mono_type_get_object (domain, D.30520);
      D.30522 = &info->utype;
      mono_gc_wbarrier_generic_store (D.30522, D.30521);
      D.30524 = mono_class_num_fields (enumc);
      if (D.30524 != 0) goto <D.30525>; else goto <D.30526>;
      <D.30525>:
      D.30527 = mono_class_num_fields (enumc);
      D.30528 = D.30527 + -1;
      iftmp.250 = (guint) D.30528;
      goto <D.30529>;
      <D.30526>:
      iftmp.250 = 0;
      <D.30529>:
      nvalues = iftmp.250;
      D.30530 = mono_defaults.string_class;
      D.30531 = mono_array_new (domain, D.30530, nvalues);
      D.30532 = &info->names;
      mono_gc_wbarrier_generic_store (D.30532, D.30531);
      D.30533 = mono_array_new (domain, enumc, nvalues);
      D.30534 = &info->values;
      mono_gc_wbarrier_generic_store (D.30534, D.30533);
      crow = 4294967295;
      iter = 0B;
      goto <D.21712>;
      <D.21748>:
      {
        const char * p;
        int len;
        MonoTypeEnum def_type;

        try
          {
            D.30535 = field->type;
            D.30536 = D.30535->attrs;
            D.30537 = (int) D.30536;
            D.30538 = D.30537 & 16;
            if (D.30538 == 0) goto <D.30539>; else goto <D.30540>;
            <D.30539>:
            // predicted unlikely by continue predictor.
            goto <D.21712>;
            <D.30540>:
            {
              size_t __s1_len;
              size_t __s2_len;

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

                __s2 = mono_field_get_name (field);
                D.30544 = "value__";
                D.30545 = MEM[(const unsigned char *)D.30544];
                D.30546 = (int) D.30545;
                D.30547 = *__s2;
                D.30548 = (int) D.30547;
                __result = D.30546 - D.30548;
                {
                  D.30549 = __s1_len != 0;
                  D.30550 = __result == 0;
                  D.30551 = D.30549 & D.30550;
                  if (D.30551 != 0) goto <D.30552>; else goto <D.30553>;
                  <D.30552>:
                  D.30554 = &MEM[(void *)"value__" + 1B];
                  D.30555 = *D.30554;
                  D.30556 = (int) D.30555;
                  D.30557 = __s2 + 1;
                  D.30558 = *D.30557;
                  D.30559 = (int) D.30558;
                  __result = D.30556 - D.30559;
                  D.30560 = __s1_len > 1;
                  D.30550 = __result == 0;
                  D.30561 = D.30560 & D.30550;
                  if (D.30561 != 0) goto <D.30562>; else goto <D.30563>;
                  <D.30562>:
                  D.30564 = &MEM[(void *)"value__" + 2B];
                  D.30565 = *D.30564;
                  D.30566 = (int) D.30565;
                  D.30567 = __s2 + 2;
                  D.30568 = *D.30567;
                  D.30569 = (int) D.30568;
                  __result = D.30566 - D.30569;
                  D.30570 = __s1_len > 2;
                  D.30550 = __result == 0;
                  D.30571 = D.30570 & D.30550;
                  if (D.30571 != 0) goto <D.30572>; else goto <D.30573>;
                  <D.30572>:
                  D.30574 = &MEM[(void *)"value__" + 3B];
                  D.30575 = *D.30574;
                  D.30576 = (int) D.30575;
                  D.30577 = __s2 + 3;
                  D.30578 = *D.30577;
                  D.30579 = (int) D.30578;
                  __result = D.30576 - D.30579;
                  <D.30573>:
                  <D.30563>:
                  <D.30553>:
                }
                D.21717 = __result;
              }
              iftmp.251 = D.21717;
              goto <D.30580>;
              <D.30543>:
              D.30581 = mono_field_get_name (field);
              iftmp.251 = __builtin_strcmp ("value__", D.30581);
              <D.30580>:
              D.21721 = iftmp.251;
            }
            if (D.21721 == 0) goto <D.30582>; else goto <D.30583>;
            <D.30582>:
            // predicted unlikely by continue predictor.
            goto <D.21712>;
            <D.30583>:
            D.30535 = field->type;
            D.30536 = D.30535->attrs;
            D.30537 = (int) D.30536;
            D.30584 = D.30537 & 1536;
            if (D.30584 != 0) goto <D.30585>; else goto <D.30586>;
            <D.30585>:
            {
              size_t __s1_len;
              size_t __s2_len;

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

                __s2 = mono_field_get_name (field);
                D.30590 = "_Deleted";
                D.30591 = MEM[(const unsigned char *)D.30590];
                D.30592 = (int) D.30591;
                D.30593 = *__s2;
                D.30594 = (int) D.30593;
                __result = D.30592 - D.30594;
                {
                  D.30595 = __s2_len != 0;
                  D.30596 = __result == 0;
                  D.30597 = D.30595 & D.30596;
                  if (D.30597 != 0) goto <D.30598>; else goto <D.30599>;
                  <D.30598>:
                  D.30600 = &MEM[(void *)"_Deleted" + 1B];
                  D.30601 = *D.30600;
                  D.30602 = (int) D.30601;
                  D.30603 = __s2 + 1;
                  D.30604 = *D.30603;
                  D.30605 = (int) D.30604;
                  __result = D.30602 - D.30605;
                  D.30606 = __s2_len > 1;
                  D.30596 = __result == 0;
                  D.30607 = D.30606 & D.30596;
                  if (D.30607 != 0) goto <D.30608>; else goto <D.30609>;
                  <D.30608>:
                  D.30610 = &MEM[(void *)"_Deleted" + 2B];
                  D.30611 = *D.30610;
                  D.30612 = (int) D.30611;
                  D.30613 = __s2 + 2;
                  D.30614 = *D.30613;
                  D.30615 = (int) D.30614;
                  __result = D.30612 - D.30615;
                  D.30616 = __s2_len > 2;
                  D.30596 = __result == 0;
                  D.30617 = D.30616 & D.30596;
                  if (D.30617 != 0) goto <D.30618>; else goto <D.30619>;
                  <D.30618>:
                  D.30620 = &MEM[(void *)"_Deleted" + 3B];
                  D.30621 = *D.30620;
                  D.30622 = (int) D.30621;
                  D.30623 = __s2 + 3;
                  D.30624 = *D.30623;
                  D.30625 = (int) D.30624;
                  __result = D.30622 - D.30625;
                  <D.30619>:
                  <D.30609>:
                  <D.30599>:
                }
                D.21729 = __result;
              }
              iftmp.252 = -D.21729;
              goto <D.30626>;
              <D.30589>:
              D.30627 = mono_field_get_name (field);
              iftmp.252 = __builtin_strcmp (D.30627, "_Deleted");
              <D.30626>:
              D.21730 = iftmp.252;
            }
            if (D.21730 == 0) goto <D.30628>; else goto <D.30629>;
            <D.30628>:
            // predicted unlikely by continue predictor.
            goto <D.21712>;
            <D.30629>:
            <D.30586>:
            {
              void * * __p;

              D.30630 = info->names;
              __p = mono_array_addr_with_size (D.30630, 4, j);
              D.30631 = mono_field_get_name (field);
              D.30632 = mono_string_new (domain, D.30631);
              D.30630 = info->names;
              mono_gc_wbarrier_set_arrayref (D.30630, __p, D.30632);
            }
            p.253 = mono_class_get_field_default_value (field, &def_type);
            p = p.253;
            p.254 = p;
            D.30635 = mono_metadata_decode_blob_size (p.254, &p);
            len = (int) D.30635;
            D.30636 = mono_class_enum_basetype (enumc);
            D.30637 = D.30636->type;
            D.30638 = (int) D.30637;
            switch (D.30638) <default: <D.21746>, case 3: <D.21736>, case 4: <D.21733>, case 5: <D.21732>, case 6: <D.21738>, case 7: <D.21737>, case 8: <D.21741>, case 9: <D.21740>, case 10: <D.21744>, case 11: <D.21743>>
            <D.21732>:
            <D.21733>:
            {
              gchar * __p;

              D.30639 = info->values;
              __p = mono_array_addr_with_size (D.30639, 1, j);
              p.254 = p;
              D.30640 = *p.254;
              *__p = D.30640;
            }
            goto <D.21735>;
            <D.21736>:
            <D.21737>:
            <D.21738>:
            {
              gint16 * __p;

              D.30639 = info->values;
              __p = mono_array_addr_with_size (D.30639, 2, j);
              p.254 = p;
              D.30641 = MEM[(const guint16 *)p.254];
              D.30642 = (short int) D.30641;
              *__p = D.30642;
            }
            goto <D.21735>;
            <D.21740>:
            <D.21741>:
            {
              gint32 * __p;

              D.30639 = info->values;
              __p = mono_array_addr_with_size (D.30639, 4, j);
              p.254 = p;
              D.30643 = MEM[(const guint32 *)p.254];
              D.30644 = (int) D.30643;
              *__p = D.30644;
            }
            goto <D.21735>;
            <D.21743>:
            <D.21744>:
            {
              gint64 * __p;

              D.30639 = info->values;
              __p = mono_array_addr_with_size (D.30639, 8, j);
              p.254 = p;
              D.30645 = MEM[(const guint64 *)p.254];
              D.30646 = (long long int) D.30645;
              *__p = D.30646;
            }
            goto <D.21735>;
            <D.21746>:
            D.30647 = mono_class_enum_basetype (enumc);
            D.30648 = D.30647->type;
            D.30649 = (int) D.30648;
            monoeg_g_log (0B, 4, "Implement type 0x%02x in get_enum_info", D.30649);
            <D.21747>:
            goto <D.21747>;
            <D.21735>:
            j = j + 1;
          }
        finally
          {
            p = {CLOBBER};
            def_type = {CLOBBER};
          }
      }
      <D.21712>:
      field = mono_class_get_fields (enumc, &iter);
      if (field != 0B) goto <D.21748>; else goto <D.21749>;
      <D.21749>:
    }
  finally
    {
      iter = {CLOBBER};
    }
}


custom_attrs_defined_internal (struct MonoObject * obj, struct MonoReflectionType * attr_type)
{
  struct MonoType * D.30652;
  MonoBoolean D.30655;
  int D.30656;
  struct MonoClass * attr_class;
  struct MonoCustomAttrInfo * cinfo;
  gboolean found;

  D.30652 = attr_type->type;
  attr_class = mono_class_from_mono_type (D.30652);
  mono_class_init_or_throw (attr_class);
  cinfo = mono_reflection_get_custom_attrs_info (obj);
  if (cinfo == 0B) goto <D.30653>; else goto <D.30654>;
  <D.30653>:
  D.30655 = 0;
  return D.30655;
  <D.30654>:
  found = mono_custom_attrs_has_attr (cinfo, attr_class);
  D.30656 = cinfo->cached;
  if (D.30656 == 0) goto <D.30657>; else goto <D.30658>;
  <D.30657>:
  mono_custom_attrs_free (cinfo);
  <D.30658>:
  D.30655 = (MonoBoolean) found;
  return D.30655;
}


custom_attrs_get_by_type (struct MonoObject * obj, struct MonoReflectionType * attr_type)
{
  struct MonoClass * iftmp.255;
  struct MonoType * D.30663;
  int D.30667;
  struct MonoLoaderError * D.30670;
  struct MonoLoaderError * D.30673;
  struct MonoException * D.30674;
  struct MonoArray * D.30675;
  struct MonoClass * attr_class;
  struct MonoArray * res;
  struct MonoError error;

  try
    {
      if (attr_type != 0B) goto <D.30661>; else goto <D.30662>;
      <D.30661>:
      D.30663 = attr_type->type;
      iftmp.255 = mono_class_from_mono_type (D.30663);
      goto <D.30664>;
      <D.30662>:
      iftmp.255 = 0B;
      <D.30664>:
      attr_class = iftmp.255;
      if (attr_class != 0B) goto <D.30665>; else goto <D.30666>;
      <D.30665>:
      mono_class_init_or_throw (attr_class);
      <D.30666>:
      res = mono_reflection_get_custom_attrs_by_type (obj, attr_class, &error);
      D.30667 = mono_error_ok (&error);
      if (D.30667 == 0) goto <D.30668>; else goto <D.30669>;
      <D.30668>:
      mono_error_raise_exception (&error);
      <D.30669>:
      D.30670 = mono_loader_get_last_error ();
      if (D.30670 != 0B) goto <D.30671>; else goto <D.30672>;
      <D.30671>:
      D.30673 = mono_loader_get_last_error ();
      D.30674 = mono_loader_error_prepare_exception (D.30673);
      mono_raise_exception (D.30674);
      monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "icall.c", 7569);
      D.30675 = 0B;
      return D.30675;
      <D.30672>:
      D.30675 = res;
      return D.30675;
    }
  finally
    {
      error = {CLOBBER};
    }
}


ves_icall_System_IO_get_temp_path ()
{
  struct MonoString * D.30678;
  const gchar * D.30679;
  struct MonoDomain * D.30680;

  D.30679 = monoeg_g_get_tmp_dir ();
  D.30680 = mono_domain_get ();
  D.30678 = mono_string_new (D.30680, D.30679);
  return D.30678;
}


ves_icall_System_IO_DriveInfo_GetDriveType (struct MonoString * root_path_name)
{
  guint32 D.30682;
  mono_unichar2 * D.30683;

  D.30683 = mono_string_chars (root_path_name);
  D.30682 = GetDriveType (D.30683);
  return D.30682;
}


ves_icall_System_IO_DriveInfo_GetDriveFormat (struct MonoString * path)
{
  mono_unichar2 * D.30685;
  int D.30686;
  struct MonoString * D.30689;
  gunichar2 volume_name[261];

  try
    {
      D.30685 = mono_string_chars (path);
      D.30686 = GetVolumeInformation (D.30685, 0B, 0, 0B, 0B, 0B, &volume_name, 261);
      if (D.30686 == 0) goto <D.30687>; else goto <D.30688>;
      <D.30687>:
      D.30689 = 0B;
      return D.30689;
      <D.30688>:
      D.30689 = mono_string_from_utf16 (&volume_name);
      return D.30689;
    }
  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.30692;
  long long unsigned int D.30695;
  long long unsigned int D.30696;
  long long unsigned int D.30697;
  unsigned int D.30699;
  int D.30700;
  MonoBoolean D.30701;
  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.30692 = mono_string_chars (path_name);
      result = GetDiskFreeSpaceEx (D.30692, &wapi_free_bytes_avail, &wapi_total_number_of_bytes, &wapi_total_number_of_free_bytes);
      if (result != 0) goto <D.30693>; else goto <D.30694>;
      <D.30693>:
      D.30695 = wapi_free_bytes_avail.QuadPart;
      *free_bytes_avail = D.30695;
      D.30696 = wapi_total_number_of_bytes.QuadPart;
      *total_number_of_bytes = D.30696;
      D.30697 = wapi_total_number_of_free_bytes.QuadPart;
      *total_number_of_free_bytes = D.30697;
      goto <D.30698>;
      <D.30694>:
      *free_bytes_avail = 0;
      *total_number_of_bytes = 0;
      *total_number_of_free_bytes = 0;
      D.30699 = GetLastError ();
      D.30700 = (int) D.30699;
      *error = D.30700;
      <D.30698>:
      D.30701 = (MonoBoolean) result;
      return D.30701;
    }
  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.30704;
  const gchar * D.30705;
  struct MonoDomain * D.30706;

  D.30705 = monoeg_g_get_home_dir ();
  D.30706 = mono_domain_get ();
  D.30704 = mono_string_new (D.30706, D.30705);
  return D.30704;
}


ves_icall_System_Environment_GetGacPath ()
{
  struct MonoString * D.30708;
  const char * D.30709;
  struct MonoDomain * D.30710;

  D.30709 = mono_assembly_getrootdir ();
  D.30710 = mono_domain_get ();
  D.30708 = mono_string_new (D.30710, D.30709);
  return D.30708;
}


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

  if (name == 0B) goto <D.30712>; else goto <D.30713>;
  <D.30712>:
  D.30714 = 0B;
  return D.30714;
  <D.30713>:
  utf8_name = mono_string_to_utf8 (name);
  value = monoeg_g_getenv (utf8_name);
  monoeg_g_free (utf8_name);
  if (value == 0B) goto <D.30715>; else goto <D.30716>;
  <D.30715>:
  D.30714 = 0B;
  return D.30714;
  <D.30716>:
  D.30717 = mono_domain_get ();
  D.30714 = mono_string_new (D.30717, value);
  return D.30714;
}


ves_icall_System_Environment_BroadcastSettingChange ()
{

}


ves_icall_System_Environment_get_Platform ()
{
  int D.30719;

  D.30719 = 4;
  return D.30719;
}


ves_icall_System_Environment_get_MachineName ()
{
  int D.30721;
  struct MonoDomain * D.30724;
  struct MonoString * D.30726;
  gchar buf[256];
  struct MonoString * result;

  try
    {
      D.30721 = gethostname (&buf, 256);
      if (D.30721 == 0) goto <D.30722>; else goto <D.30723>;
      <D.30722>:
      D.30724 = mono_domain_get ();
      result = mono_string_new (D.30724, &buf);
      goto <D.30725>;
      <D.30723>:
      result = 0B;
      <D.30725>:
      D.30726 = result;
      return D.30726;
    }
  finally
    {
      buf = {CLOBBER};
    }
}


gethostname (char * __buf, size_t __buflen)
{
  unsigned int D.30729;
  int D.30732;
  int D.30735;
  unsigned int D.30736;
  unsigned int D.30737;
  unsigned int D.30740;

  D.30729 = __builtin_object_size (__buf, 1);
  if (D.30729 != 4294967295) goto <D.30730>; else goto <D.30731>;
  <D.30730>:
  D.30732 = __builtin_constant_p (__buflen);
  if (D.30732 == 0) goto <D.30733>; else goto <D.30734>;
  <D.30733>:
  D.30736 = __builtin_object_size (__buf, 1);
  D.30735 = __gethostname_chk (__buf, __buflen, D.30736);
  return D.30735;
  <D.30734>:
  D.30737 = __builtin_object_size (__buf, 1);
  if (D.30737 < __buflen) goto <D.30738>; else goto <D.30739>;
  <D.30738>:
  D.30740 = __builtin_object_size (__buf, 1);
  D.30735 = __gethostname_chk_warn (__buf, __buflen, D.30740);
  return D.30735;
  <D.30739>:
  <D.30731>:
  D.30735 = __gethostname_alias (__buf, __buflen);
  return D.30735;
}


ves_icall_System_Environment_get_HasShutdownStarted ()
{
  int D.30742;
  MonoBoolean D.30745;
  struct MonoDomain * D.30746;
  int D.30747;

  D.30742 = mono_runtime_is_shutting_down ();
  if (D.30742 != 0) goto <D.30743>; else goto <D.30744>;
  <D.30743>:
  D.30745 = 1;
  return D.30745;
  <D.30744>:
  D.30746 = mono_domain_get ();
  D.30747 = mono_domain_is_unloading (D.30746);
  if (D.30747 != 0) goto <D.30748>; else goto <D.30749>;
  <D.30748>:
  D.30745 = 1;
  return D.30745;
  <D.30749>:
  D.30745 = 0;
  return D.30745;
}


ves_icall_System_Environment_InternalSetEnvironmentVariable (struct MonoString * name, struct MonoString * value)
{
  int D.30754;
  mono_unichar2 * D.30756;
  short unsigned int D.30757;
  int D.30758;
  struct MonoError error;
  gchar * utf8_name;
  gchar * utf8_value;

  try
    {
      utf8_name = mono_string_to_utf8 (name);
      if (value == 0B) goto <D.30751>; else goto <D.30753>;
      <D.30753>:
      D.30754 = mono_string_length (value);
      if (D.30754 == 0) goto <D.30751>; else goto <D.30755>;
      <D.30755>:
      D.30756 = mono_string_chars (value);
      D.30757 = *D.30756;
      if (D.30757 == 0) goto <D.30751>; else goto <D.30752>;
      <D.30751>:
      monoeg_g_unsetenv (utf8_name);
      monoeg_g_free (utf8_name);
      return;
      <D.30752>:
      utf8_value = mono_string_to_utf8_checked (value, &error);
      D.30758 = mono_error_ok (&error);
      if (D.30758 == 0) goto <D.30759>; else goto <D.30760>;
      <D.30759>:
      monoeg_g_free (utf8_name);
      mono_error_raise_exception (&error);
      <D.30760>:
      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.30764;
  struct MonoDomain * D.30765;

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


ves_icall_System_Environment_get_NewLine ()
{
  struct MonoString * D.30767;
  struct MonoDomain * D.30768;

  D.30768 = mono_domain_get ();
  D.30767 = mono_string_new (D.30768, "\n");
  return D.30767;
}


ves_icall_System_Environment_GetLogicalDrives ()
{
  int D.30770;
  unsigned int D.30775;
  unsigned int D.30776;
  gunichar2 * dname.256;
  short unsigned int D.30778;
  short unsigned int D.30779;
  unsigned int ndrives.257;
  struct MonoClass * D.30781;
  short unsigned int D.30782;
  int ndrives.258;
  unsigned int ndrives.259;
  gunichar2 * dname.260;
  short unsigned int D.30786;
  struct MonoArray * D.30789;
  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.22904>;
      <D.22903>:
      D.30770 = GetLogicalDriveStrings (initial_size, ptr);
      size = (guint) D.30770;
      if (size > initial_size) goto <D.30771>; else goto <D.30772>;
      <D.30771>:
      if (&buf != ptr) goto <D.30773>; else goto <D.30774>;
      <D.30773>:
      monoeg_g_free (ptr);
      <D.30774>:
      D.30775 = size + 1;
      D.30776 = D.30775 * 2;
      ptr = monoeg_malloc0 (D.30776);
      initial_size = size;
      size = size + 1;
      <D.30772>:
      <D.22904>:
      if (size > initial_size) goto <D.22903>; else goto <D.22905>;
      <D.22905>:
      dname = ptr;
      ndrives = 0;
      <D.22909>:
      goto <D.22907>;
      <D.22906>:
      <D.22907>:
      dname.256 = dname;
      dname = dname.256 + 2;
      D.30778 = *dname.256;
      if (D.30778 != 0) goto <D.22906>; else goto <D.22908>;
      <D.22908>:
      ndrives = ndrives + 1;
      D.30779 = *dname;
      if (D.30779 != 0) goto <D.22909>; else goto <D.22910>;
      <D.22910>:
      dname = ptr;
      ndrives.257 = (unsigned int) ndrives;
      D.30781 = mono_defaults.string_class;
      result = mono_array_new (domain, D.30781, ndrives.257);
      ndrives = 0;
      <D.22918>:
      len = 0;
      u16 = dname;
      goto <D.22912>;
      <D.22911>:
      u16 = u16 + 2;
      len = len + 1;
      <D.22912>:
      D.30782 = *u16;
      if (D.30782 != 0) goto <D.22911>; else goto <D.22913>;
      <D.22913>:
      drivestr = mono_string_new_utf16 (domain, dname, len);
      {
        void * * __p;

        ndrives.258 = ndrives;
        ndrives = ndrives.258 + 1;
        ndrives.259 = (unsigned int) ndrives.258;
        __p = mono_array_addr_with_size (result, 4, ndrives.259);
        mono_gc_wbarrier_set_arrayref (result, __p, drivestr);
      }
      goto <D.22916>;
      <D.22915>:
      <D.22916>:
      dname.260 = dname;
      dname = dname.260 + 2;
      D.30786 = *dname.260;
      if (D.30786 != 0) goto <D.22915>; else goto <D.22917>;
      <D.22917>:
      D.30779 = *dname;
      if (D.30779 != 0) goto <D.22918>; else goto <D.22919>;
      <D.22919>:
      if (&buf != ptr) goto <D.30787>; else goto <D.30788>;
      <D.30787>:
      monoeg_g_free (ptr);
      <D.30788>:
      D.30789 = result;
      return D.30789;
    }
  finally
    {
      buf = {CLOBBER};
    }
}


ves_icall_System_Environment_GetEnvironmentVariableNames ()
{
  gchar * D.30792;
  unsigned int n.261;
  struct MonoClass * D.30794;
  gchar * D.30795;
  struct MonoArray * D.30798;
  struct MonoArray * names;
  struct MonoDomain * domain;
  struct MonoString * str;
  gchar * * e;
  gchar * * parts;
  int n;

  n = 0;
  e = environ;
  goto <D.22867>;
  <D.22866>:
  n = n + 1;
  e = e + 4;
  <D.22867>:
  D.30792 = *e;
  if (D.30792 != 0B) goto <D.22866>; else goto <D.22868>;
  <D.22868>:
  domain = mono_domain_get ();
  n.261 = (unsigned int) n;
  D.30794 = mono_defaults.string_class;
  names = mono_array_new (domain, D.30794, n.261);
  n = 0;
  e = environ;
  goto <D.22871>;
  <D.22870>:
  D.30792 = *e;
  parts = monoeg_g_strsplit (D.30792, "=", 2);
  D.30795 = *parts;
  if (D.30795 != 0B) goto <D.30796>; else goto <D.30797>;
  <D.30796>:
  D.30795 = *parts;
  str = mono_string_new (domain, D.30795);
  {
    void * * __p;

    n.261 = (unsigned int) n;
    __p = mono_array_addr_with_size (names, 4, n.261);
    mono_gc_wbarrier_set_arrayref (names, __p, str);
  }
  <D.30797>:
  monoeg_g_strfreev (parts);
  n = n + 1;
  e = e + 4;
  <D.22871>:
  D.30792 = *e;
  if (D.30792 != 0B) goto <D.22870>; else goto <D.22872>;
  <D.22872>:
  D.30798 = names;
  return D.30798;
}


ves_icall_System_Environment_Exit (int result)
{
  int D.30800;

  mono_environment_exitcode_set (result);
  D.30800 = mono_runtime_try_shutdown ();
  if (D.30800 == 0) goto <D.30801>; else goto <D.30802>;
  <D.30801>:
  mono_thread_exit ();
  <D.30802>:
  mono_thread_suspend_all_other_threads ();
  mono_runtime_quit ();
  exit (result);
}


ves_icall_System_Enum_get_value (struct MonoObject * this)
{
  struct MonoObject * D.30805;
  struct MonoVTable * D.30806;
  struct MonoClass * D.30807;
  unsigned char D.30808;
  unsigned char D.30809;
  _Bool D.30810;
  long int D.30811;
  long int D.30812;
  struct MonoType * D.30815;
  struct MonoDomain * D.30816;
  unsigned int size.262;
  struct MonoObject * res;
  struct MonoClass * enumc;
  void * dst;
  void * src;
  int size;

  if (this == 0B) goto <D.30803>; else goto <D.30804>;
  <D.30803>:
  D.30805 = 0B;
  return D.30805;
  <D.30804>:
  D.30806 = this->vtable;
  D.30807 = D.30806->klass;
  D.30808 = BIT_FIELD_REF <*D.30807, 8, 160>;
  D.30809 = D.30808 & 16;
  D.30810 = D.30809 == 0;
  D.30811 = (long int) D.30810;
  D.30812 = __builtin_expect (D.30811, 0);
  if (D.30812 != 0) goto <D.30813>; else goto <D.30814>;
  <D.30813>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "icall.c", 3088, "this->vtable->klass->enumtype");
  <D.30814>:
  D.30806 = this->vtable;
  D.30807 = D.30806->klass;
  D.30815 = mono_class_enum_basetype (D.30807);
  enumc = mono_class_from_mono_type (D.30815);
  D.30806 = this->vtable;
  D.30816 = D.30806->domain;
  res = mono_object_new (D.30816, enumc);
  dst = res + 8;
  src = this + 8;
  size = mono_class_value_size (enumc, 0B);
  size.262 = (unsigned int) size;
  memcpy (dst, src, size.262);
  D.30805 = res;
  return D.30805;
}


ves_icall_System_Enum_get_underlying_type (struct MonoReflectionType * type)
{
  struct MonoType * D.30819;
  struct MonoException * D.30822;
  struct MonoReflectionType * D.30823;
  struct MonoVTable * D.30824;
  struct MonoDomain * D.30825;
  struct MonoType * etype;
  struct MonoClass * klass;

  D.30819 = type->type;
  klass = mono_class_from_mono_type (D.30819);
  mono_class_init_or_throw (klass);
  etype = mono_class_enum_basetype (klass);
  if (etype == 0B) goto <D.30820>; else goto <D.30821>;
  <D.30820>:
  D.30822 = mono_get_exception_argument ("Type must be a type provided by the runtime.", "enumType");
  mono_raise_exception (D.30822);
  <D.30821>:
  D.30824 = MEM[(struct MonoObject *)type].vtable;
  D.30825 = D.30824->domain;
  D.30823 = mono_type_get_object (D.30825, etype);
  return D.30823;
}


ves_icall_System_Enum_get_hashcode (struct MonoObject * this)
{
  struct MonoVTable * D.30827;
  struct MonoClass * D.30828;
  _Bool D.30829;
  long int D.30830;
  long int D.30831;
  unsigned char D.30834;
  int D.30835;
  int D.30836;
  signed char D.30837;
  unsigned char D.30838;
  short unsigned int D.30839;
  short int D.30840;
  unsigned int D.30841;
  int D.30842;
  long long int D.30843;
  int D.30844;
  void * data;
  struct MonoType * basetype;

  data = this + 8;
  D.30827 = this->vtable;
  D.30828 = D.30827->klass;
  basetype = mono_class_enum_basetype (D.30828);
  D.30829 = basetype == 0B;
  D.30830 = (long int) D.30829;
  D.30831 = __builtin_expect (D.30830, 0);
  if (D.30831 != 0) goto <D.30832>; else goto <D.30833>;
  <D.30832>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "icall.c", 3175, "basetype");
  <D.30833>:
  D.30834 = basetype->type;
  D.30835 = (int) D.30834;
  switch (D.30835) <default: <D.21696>, case 3: <D.21688>, case 4: <D.21686>, case 5: <D.21687>, case 6: <D.21690>, case 7: <D.21689>, case 8: <D.21692>, case 9: <D.21691>, case 10: <D.21694>, case 11: <D.21693>>
  <D.21686>:
  D.30837 = MEM[(gint8 *)data];
  D.30836 = (int) D.30837;
  return D.30836;
  <D.21687>:
  D.30838 = MEM[(guint8 *)data];
  D.30836 = (int) D.30838;
  return D.30836;
  <D.21688>:
  <D.21689>:
  D.30839 = MEM[(guint16 *)data];
  D.30836 = (int) D.30839;
  return D.30836;
  <D.21690>:
  D.30840 = MEM[(gint16 *)data];
  D.30836 = (int) D.30840;
  return D.30836;
  <D.21691>:
  D.30841 = MEM[(guint32 *)data];
  D.30836 = (int) D.30841;
  return D.30836;
  <D.21692>:
  D.30836 = MEM[(gint32 *)data];
  return D.30836;
  <D.21693>:
  <D.21694>:
  {
    gint64 value;

    value = MEM[(gint64 *)data];
    D.30842 = (int) value;
    D.30843 = value >> 32;
    D.30844 = (int) D.30843;
    D.30836 = D.30842 ^ D.30844;
    return D.30836;
  }
  <D.21696>:
  D.30834 = basetype->type;
  D.30835 = (int) D.30834;
  monoeg_g_log (0B, 4, "Implement type 0x%02x in get_hashcode", D.30835);
  <D.21697>:
  goto <D.21697>;
  D.30836 = 0;
  return D.30836;
}


ves_icall_System_Enum_compare_value_to (struct MonoObject * this, struct MonoObject * other)
{
  struct MonoVTable * D.30846;
  struct MonoClass * D.30847;
  _Bool D.30848;
  long int D.30849;
  long int D.30850;
  unsigned char D.30853;
  int D.30854;
  int D.30857;
  int iftmp.263;
  int iftmp.264;
  int D.30870;
  int D.30871;
  int iftmp.265;
  int iftmp.266;
  int iftmp.267;
  int iftmp.268;
  int iftmp.269;
  void * tdata;
  void * odata;
  struct MonoType * basetype;

  tdata = this + 8;
  odata = other + 8;
  D.30846 = this->vtable;
  D.30847 = D.30846->klass;
  basetype = mono_class_enum_basetype (D.30847);
  D.30848 = basetype == 0B;
  D.30849 = (long int) D.30848;
  D.30850 = __builtin_expect (D.30849, 0);
  if (D.30850 != 0) goto <D.30851>; else goto <D.30852>;
  <D.30851>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "icall.c", 3126, "basetype");
  <D.30852>:
  D.30853 = basetype->type;
  D.30854 = (int) D.30853;
  switch (D.30854) <default: <D.21679>, case 3: <D.21660>, case 4: <D.21657>, case 5: <D.21654>, case 6: <D.21664>, case 7: <D.21661>, case 8: <D.21670>, case 9: <D.21667>, case 10: <D.21676>, case 11: <D.21673>>
  <D.21654>:
  {
    guint8 me;
    guint8 other;

    me = MEM[(guint8 *)tdata];
    other = MEM[(guint8 *)odata];
    if (me == other) goto <D.30855>; else goto <D.30856>;
    <D.30855>:
    D.30857 = 0;
    return D.30857;
    <D.30856>:
    if (me > other) goto <D.30859>; else goto <D.30860>;
    <D.30859>:
    iftmp.263 = 1;
    goto <D.30861>;
    <D.30860>:
    iftmp.263 = -1;
    <D.30861>:
    D.30857 = iftmp.263;
    return D.30857;
  }
  <D.21657>:
  {
    gint8 me;
    gint8 other;

    me = MEM[(gint8 *)tdata];
    other = MEM[(gint8 *)odata];
    if (me == other) goto <D.30862>; else goto <D.30863>;
    <D.30862>:
    D.30857 = 0;
    return D.30857;
    <D.30863>:
    if (me > other) goto <D.30865>; else goto <D.30866>;
    <D.30865>:
    iftmp.264 = 1;
    goto <D.30867>;
    <D.30866>:
    iftmp.264 = -1;
    <D.30867>:
    D.30857 = iftmp.264;
    return D.30857;
  }
  <D.21660>:
  <D.21661>:
  {
    guint16 me;
    guint16 other;

    me = MEM[(guint16 *)tdata];
    other = MEM[(guint16 *)odata];
    if (me == other) goto <D.30868>; else goto <D.30869>;
    <D.30868>:
    D.30857 = 0;
    return D.30857;
    <D.30869>:
    D.30870 = (int) me;
    D.30871 = (int) other;
    D.30857 = D.30870 - D.30871;
    return D.30857;
  }
  <D.21664>:
  {
    gint16 me;
    gint16 other;

    me = MEM[(gint16 *)tdata];
    other = MEM[(gint16 *)odata];
    if (me == other) goto <D.30872>; else goto <D.30873>;
    <D.30872>:
    D.30857 = 0;
    return D.30857;
    <D.30873>:
    if (me > other) goto <D.30875>; else goto <D.30876>;
    <D.30875>:
    iftmp.265 = 1;
    goto <D.30877>;
    <D.30876>:
    iftmp.265 = -1;
    <D.30877>:
    D.30857 = iftmp.265;
    return D.30857;
  }
  <D.21667>:
  {
    guint32 me;
    guint32 other;

    me = MEM[(guint32 *)tdata];
    other = MEM[(guint32 *)odata];
    if (me == other) goto <D.30878>; else goto <D.30879>;
    <D.30878>:
    D.30857 = 0;
    return D.30857;
    <D.30879>:
    if (me > other) goto <D.30881>; else goto <D.30882>;
    <D.30881>:
    iftmp.266 = 1;
    goto <D.30883>;
    <D.30882>:
    iftmp.266 = -1;
    <D.30883>:
    D.30857 = iftmp.266;
    return D.30857;
  }
  <D.21670>:
  {
    gint32 me;
    gint32 other;

    me = MEM[(gint32 *)tdata];
    other = MEM[(gint32 *)odata];
    if (me == other) goto <D.30884>; else goto <D.30885>;
    <D.30884>:
    D.30857 = 0;
    return D.30857;
    <D.30885>:
    if (me > other) goto <D.30887>; else goto <D.30888>;
    <D.30887>:
    iftmp.267 = 1;
    goto <D.30889>;
    <D.30888>:
    iftmp.267 = -1;
    <D.30889>:
    D.30857 = iftmp.267;
    return D.30857;
  }
  <D.21673>:
  {
    guint64 me;
    guint64 other;

    me = MEM[(guint64 *)tdata];
    other = MEM[(guint64 *)odata];
    if (me == other) goto <D.30890>; else goto <D.30891>;
    <D.30890>:
    D.30857 = 0;
    return D.30857;
    <D.30891>:
    if (me > other) goto <D.30893>; else goto <D.30894>;
    <D.30893>:
    iftmp.268 = 1;
    goto <D.30895>;
    <D.30894>:
    iftmp.268 = -1;
    <D.30895>:
    D.30857 = iftmp.268;
    return D.30857;
  }
  <D.21676>:
  {
    gint64 me;
    gint64 other;

    me = MEM[(gint64 *)tdata];
    other = MEM[(gint64 *)odata];
    if (me == other) goto <D.30896>; else goto <D.30897>;
    <D.30896>:
    D.30857 = 0;
    return D.30857;
    <D.30897>:
    if (me > other) goto <D.30899>; else goto <D.30900>;
    <D.30899>:
    iftmp.269 = 1;
    goto <D.30901>;
    <D.30900>:
    iftmp.269 = -1;
    <D.30901>:
    D.30857 = iftmp.269;
    return D.30857;
  }
  <D.21679>:
  D.30853 = basetype->type;
  D.30854 = (int) D.30853;
  monoeg_g_log (0B, 4, "Implement type 0x%02x in get_hashcode", D.30854);
  <D.21680>:
  goto <D.21680>;
  D.30857 = 0;
  return D.30857;
}


ves_icall_System_Enum_ToObject (struct MonoReflectionType * enumType, struct MonoObject * value)
{
  _Bool D.30903;
  long int D.30904;
  long int D.30905;
  _Bool D.30910;
  long int D.30911;
  long int D.30912;
  struct MonoVTable * D.30917;
  struct MonoType * D.30918;
  struct MonoVTable * D.30919;
  unsigned char D.30920;
  unsigned char D.30921;
  struct MonoException * D.30924;
  unsigned char D.30925;
  unsigned char D.30926;
  unsigned char D.30929;
  unsigned char D.30930;
  struct MonoException * D.30933;
  struct MonoException * D.30936;
  int iftmp.270;
  struct MonoType * D.30940;
  unsigned char D.30941;
  char * D.30943;
  unsigned char D.30944;
  int D.30945;
  char * D.30946;
  struct MonoObject * D.30947;
  struct MonoDomain * domain;
  struct MonoClass * enumc;
  struct MonoClass * objc;
  struct MonoObject * res;
  struct MonoType * etype;
  guint64 val;

  D.30903 = enumType == 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>:
  {
    struct MonoException * ex;

    if (enumType != 0B) goto <D.30908>; else goto <D.30909>;
    <D.30908>:
    <D.30909>:
    ex = mono_get_exception_argument_null ("enumType");
    mono_raise_exception (ex);
  }
  <D.30907>:
  D.30910 = value == 0B;
  D.30911 = (long int) D.30910;
  D.30912 = __builtin_expect (D.30911, 0);
  if (D.30912 != 0) goto <D.30913>; else goto <D.30914>;
  <D.30913>:
  {
    struct MonoException * ex;

    if (value != 0B) goto <D.30915>; else goto <D.30916>;
    <D.30915>:
    <D.30916>:
    ex = mono_get_exception_argument_null ("value");
    mono_raise_exception (ex);
  }
  <D.30914>:
  D.30917 = MEM[(struct MonoObject *)enumType].vtable;
  domain = D.30917->domain;
  D.30918 = enumType->type;
  enumc = mono_class_from_mono_type (D.30918);
  mono_class_init_or_throw (enumc);
  D.30919 = value->vtable;
  objc = D.30919->klass;
  D.30920 = BIT_FIELD_REF <*enumc, 8, 160>;
  D.30921 = D.30920 & 16;
  if (D.30921 == 0) goto <D.30922>; else goto <D.30923>;
  <D.30922>:
  D.30924 = mono_get_exception_argument ("enumType", "Type provided must be an Enum.");
  mono_raise_exception (D.30924);
  <D.30923>:
  D.30925 = BIT_FIELD_REF <*objc, 8, 160>;
  D.30926 = D.30925 & 16;
  if (D.30926 == 0) goto <D.30927>; else goto <D.30928>;
  <D.30927>:
  D.30929 = objc->byval_arg.type;
  D.30930 = D.30929 + 252;
  if (D.30930 > 7) goto <D.30931>; else goto <D.30932>;
  <D.30931>:
  D.30933 = 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.30933);
  <D.30932>:
  <D.30928>:
  etype = mono_class_enum_basetype (enumc);
  if (etype == 0B) goto <D.30934>; else goto <D.30935>;
  <D.30934>:
  D.30936 = mono_get_exception_argument ("Type must be a type provided by the runtime.", "enumType");
  mono_raise_exception (D.30936);
  <D.30935>:
  res = mono_object_new (domain, enumc);
  D.30925 = BIT_FIELD_REF <*objc, 8, 160>;
  D.30926 = D.30925 & 16;
  if (D.30926 != 0) goto <D.30938>; else goto <D.30939>;
  <D.30938>:
  D.30940 = mono_class_enum_basetype (objc);
  D.30941 = D.30940->type;
  iftmp.270 = (int) D.30941;
  goto <D.30942>;
  <D.30939>:
  D.30929 = objc->byval_arg.type;
  iftmp.270 = (int) D.30929;
  <D.30942>:
  D.30943 = value + 8;
  val = read_enum_value (D.30943, iftmp.270);
  D.30944 = etype->type;
  D.30945 = (int) D.30944;
  D.30946 = res + 8;
  write_enum_value (D.30946, D.30945, val);
  D.30947 = res;
  return D.30947;
}


read_enum_value (char * mem, int type)
{
  guint64 D.30949;
  unsigned char D.30950;
  signed char D.30951;
  short unsigned int D.30952;
  short int D.30953;
  unsigned int D.30954;
  int D.30955;
  long long int D.30956;

  switch (type) <default: <D.21602>, case 4: <D.21595>, case 5: <D.21594>, case 6: <D.21597>, case 7: <D.21596>, case 8: <D.21599>, case 9: <D.21598>, case 10: <D.21601>, case 11: <D.21600>>
  <D.21594>:
  D.30950 = MEM[(guint8 *)mem];
  D.30949 = (guint64) D.30950;
  return D.30949;
  <D.21595>:
  D.30951 = MEM[(gint8 *)mem];
  D.30949 = (guint64) D.30951;
  return D.30949;
  <D.21596>:
  D.30952 = MEM[(guint16 *)mem];
  D.30949 = (guint64) D.30952;
  return D.30949;
  <D.21597>:
  D.30953 = MEM[(gint16 *)mem];
  D.30949 = (guint64) D.30953;
  return D.30949;
  <D.21598>:
  D.30954 = MEM[(guint32 *)mem];
  D.30949 = (guint64) D.30954;
  return D.30949;
  <D.21599>:
  D.30955 = MEM[(gint32 *)mem];
  D.30949 = (guint64) D.30955;
  return D.30949;
  <D.21600>:
  D.30949 = MEM[(guint64 *)mem];
  return D.30949;
  <D.21601>:
  D.30956 = MEM[(gint64 *)mem];
  D.30949 = (guint64) D.30956;
  return D.30949;
  <D.21602>:
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "icall.c", 2997);
  D.30949 = 0;
  return D.30949;
}


write_enum_value (char * mem, int type, guint64 value)
{
  unsigned char D.30958;
  short unsigned int D.30959;
  unsigned int D.30960;

  switch (type) <default: <D.21621>, case 4: <D.21609>, case 5: <D.21608>, case 6: <D.21613>, case 7: <D.21612>, case 8: <D.21616>, case 9: <D.21615>, case 10: <D.21619>, case 11: <D.21618>>
  <D.21608>:
  <D.21609>:
  {
    guint8 * p;

    p = mem;
    D.30958 = (unsigned char) value;
    *p = D.30958;
    goto <D.21611>;
  }
  <D.21612>:
  <D.21613>:
  {
    guint16 * p;

    p = mem;
    D.30959 = (short unsigned int) value;
    *p = D.30959;
    goto <D.21611>;
  }
  <D.21615>:
  <D.21616>:
  {
    guint32 * p;

    p = mem;
    D.30960 = (unsigned int) value;
    *p = D.30960;
    goto <D.21611>;
  }
  <D.21618>:
  <D.21619>:
  {
    guint64 * p;

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


mono_double_ParseImpl (char * ptr, double * result)
{
  char D.30962;
  _Bool D.30967;
  long int D.30968;
  long int D.30969;
  double D.30972;
  _Bool D.30975;
  long int D.30976;
  long int D.30977;
  gchar * endptr.271;
  char D.30985;
  gboolean D.30986;
  gchar * endptr;

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

        ret = pthread_mutex_lock (&mono_strtod_mutex.mutex);
        if (ret != 0) goto <D.30965>; else goto <D.30966>;
        <D.30965>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
        <D.30966>:
        D.30967 = ret != 0;
        D.30968 = (long int) D.30967;
        D.30969 = __builtin_expect (D.30968, 0);
        if (D.30969 != 0) goto <D.30970>; else goto <D.30971>;
        <D.30970>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "icall.c", 133, "ret == 0");
        <D.30971>:
      }
      D.30972 = mono_strtod (ptr, &endptr);
      *result = D.30972;
      {
        int ret;

        ret = pthread_mutex_unlock (&mono_strtod_mutex.mutex);
        if (ret != 0) goto <D.30973>; else goto <D.30974>;
        <D.30973>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
        <D.30974>:
        D.30975 = ret != 0;
        D.30976 = (long int) D.30975;
        D.30977 = __builtin_expect (D.30976, 0);
        if (D.30977 != 0) goto <D.30978>; else goto <D.30979>;
        <D.30978>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "icall.c", 135, "ret == 0");
        <D.30979>:
      }
      <D.30964>:
      D.30962 = *ptr;
      if (D.30962 == 0) goto <D.30980>; else goto <D.30982>;
      <D.30982>:
      endptr.271 = endptr;
      if (endptr.271 != 0B) goto <D.30984>; else goto <D.30981>;
      <D.30984>:
      endptr.271 = endptr;
      D.30985 = *endptr.271;
      if (D.30985 != 0) goto <D.30980>; else goto <D.30981>;
      <D.30980>:
      D.30986 = 0;
      return D.30986;
      <D.30981>:
      D.30986 = 1;
      return D.30986;
    }
  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.30989;
  void (*<T26fa>) (int, struct MonoString *, struct MonoString *) D.30990;
  struct MonoRuntimeCallbacks * D.30993;
  void (*<T26fa>) (int, struct MonoString *, struct MonoString *) D.30994;

  D.30989 = mono_get_runtime_callbacks ();
  D.30990 = D.30989->debug_log;
  if (D.30990 != 0B) goto <D.30991>; else goto <D.30992>;
  <D.30991>:
  D.30993 = mono_get_runtime_callbacks ();
  D.30994 = D.30993->debug_log;
  D.30994 (level, category, message);
  <D.30992>:
}


ves_icall_System_Diagnostics_Debugger_IsLogging ()
{
  struct MonoRuntimeCallbacks * D.30995;
  gboolean (*<T26fe>) (void) D.30996;
  MonoBoolean D.30999;
  struct MonoRuntimeCallbacks * D.31000;
  gboolean (*<T26fe>) (void) D.31001;
  int D.31002;

  D.30995 = mono_get_runtime_callbacks ();
  D.30996 = D.30995->debug_log_is_enabled;
  if (D.30996 != 0B) goto <D.30997>; else goto <D.30998>;
  <D.30997>:
  D.31000 = mono_get_runtime_callbacks ();
  D.31001 = D.31000->debug_log_is_enabled;
  D.31002 = D.31001 ();
  D.30999 = (MonoBoolean) D.31002;
  return D.30999;
  <D.30998>:
  D.30999 = 0;
  return D.30999;
}


ves_icall_System_Diagnostics_Debugger_IsAttached_internal ()
{
  MonoBoolean D.31004;
  int D.31005;

  D.31005 = mono_is_debugger_attached ();
  D.31004 = (MonoBoolean) D.31005;
  return D.31004;
}


ves_icall_System_Delegate_SetMulticastInvoke (struct MonoDelegate * this)
{
  struct MonoVTable * D.31007;
  struct MonoClass * D.31008;
  void * D.31009;

  D.31007 = this->object.vtable;
  D.31008 = D.31007->klass;
  D.31009 = mono_runtime_create_delegate_trampoline (D.31008);
  this->invoke_impl = D.31009;
}


ves_icall_System_Delegate_CreateDelegate_internal (struct MonoReflectionType * type, struct MonoObject * target, struct MonoReflectionMethod * info, MonoBoolean throwOnBindFailure)
{
  struct MonoType * D.31010;
  struct MonoClass * D.31011;
  struct MonoClass * D.31012;
  <unnamed type> D.31015;
  int D.31018;
  int D.31019;
  struct MonoObject * D.31022;
  struct MonoVTable * D.31023;
  struct MonoDomain * D.31024;
  unsigned char D.31025;
  unsigned char D.31026;
  short unsigned int D.31032;
  int D.31033;
  int D.31034;
  struct MonoClass * D.31037;
  struct MonoVTable * D.31038;
  struct MonoClass * D.31039;
  struct MonoDomain * D.31042;
  void * D.31043;
  struct MonoDomain * D.31044;
  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.31010 = type->type;
  delegate_class = mono_class_from_mono_type (D.31010);
  method = info->method;
  mono_class_init_or_throw (delegate_class);
  D.31011 = delegate_class->parent;
  D.31012 = mono_defaults.multicastdelegate_class;
  if (D.31011 != D.31012) goto <D.31013>; else goto <D.31014>;
  <D.31013>:
  {
    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.31014>:
  D.31015 = mono_security_get_mode ();
  if (D.31015 == 1) goto <D.31016>; else goto <D.31017>;
  <D.31016>:
  D.31018 = (int) throwOnBindFailure;
  D.31019 = mono_security_core_clr_ensure_delegate_creation (method, D.31018);
  if (D.31019 == 0) goto <D.31020>; else goto <D.31021>;
  <D.31020>:
  D.31022 = 0B;
  return D.31022;
  <D.31021>:
  <D.31017>:
  D.31023 = MEM[(struct MonoObject *)type].vtable;
  D.31024 = D.31023->domain;
  delegate = mono_object_new (D.31024, delegate_class);
  D.31025 = BIT_FIELD_REF <*method, 8, 168>;
  D.31026 = D.31025 & 2;
  if (D.31026 != 0) goto <D.31027>; else goto <D.31028>;
  <D.31027>:
  func = mono_compile_method (method);
  goto <D.31029>;
  <D.31028>:
  if (target != 0B) goto <D.31030>; else goto <D.31031>;
  <D.31030>:
  D.31032 = method->flags;
  D.31033 = (int) D.31032;
  D.31034 = D.31033 & 64;
  if (D.31034 != 0) goto <D.31035>; else goto <D.31036>;
  <D.31035>:
  D.31037 = method->klass;
  D.31038 = target->vtable;
  D.31039 = D.31038->klass;
  if (D.31037 != D.31039) goto <D.31040>; else goto <D.31041>;
  <D.31040>:
  method = mono_object_get_virtual_method (target, method);
  <D.31041>:
  <D.31036>:
  <D.31031>:
  D.31042 = mono_domain_get ();
  D.31043 = mono_runtime_create_jump_trampoline (D.31042, method, 1);
  D.31044 = mono_domain_get ();
  func = mono_create_ftnptr (D.31044, D.31043);
  <D.31029>:
  mono_delegate_ctor_with_method (delegate, target, func, method);
  D.31022 = delegate;
  return D.31022;
}


ves_icall_System_CurrentSystemTimeZone_GetTimeZoneData (guint32 year, struct MonoArray * * data, struct MonoArray * * names)
{
  _Bool D.31046;
  long int D.31047;
  long int D.31048;
  _Bool D.31053;
  long int D.31054;
  long int D.31055;
  struct MonoClass * D.31060;
  struct MonoArray * D.31061;
  struct MonoClass * D.31062;
  struct MonoArray * D.31063;
  unsigned int D.31064;
  int D.31065;
  long int t.272;
  unsigned int D.31069;
  long int t.273;
  long int t.274;
  struct tm * D.31073;
  struct MonoArray * D.31074;
  struct MonoString * D.31075;
  struct MonoString * D.31076;
  guint32 D.31077;
  long int t.275;
  struct tm * D.31079;
  long int t1.276;
  long int t1.277;
  struct tm * D.31084;
  int D.31085;
  long int t1.278;
  struct tm * D.31087;
  int D.31088;
  long int t1.279;
  int D.31090;
  struct MonoString * D.31093;
  struct MonoArray * D.31094;
  long long unsigned int D.31095;
  long long unsigned int D.31096;
  long long unsigned int D.31097;
  long long int D.31098;
  struct MonoString * D.31102;
  int D.31105;
  long long int D.31108;
  long long int D.31109;
  long int D.31110;
  long long int D.31111;
  long long int D.31112;
  _Bool D.31113;
  _Bool D.31114;
  _Bool D.31115;
  struct MonoString * D.31118;
  struct MonoString * D.31119;
  long long int D.31120;
  long long int D.31121;
  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.31046 = data == 0B;
      D.31047 = (long int) D.31046;
      D.31048 = __builtin_expect (D.31047, 0);
      if (D.31048 != 0) goto <D.31049>; else goto <D.31050>;
      <D.31049>:
      {
        struct MonoException * ex;

        if (data != 0B) goto <D.31051>; else goto <D.31052>;
        <D.31051>:
        <D.31052>:
        ex = mono_get_exception_argument_null ("data");
        mono_raise_exception (ex);
      }
      <D.31050>:
      D.31053 = names == 0B;
      D.31054 = (long int) D.31053;
      D.31055 = __builtin_expect (D.31054, 0);
      if (D.31055 != 0) goto <D.31056>; else goto <D.31057>;
      <D.31056>:
      {
        struct MonoException * ex;

        if (names != 0B) goto <D.31058>; else goto <D.31059>;
        <D.31058>:
        <D.31059>:
        ex = mono_get_exception_argument_null ("names");
        mono_raise_exception (ex);
      }
      <D.31057>:
      D.31060 = mono_defaults.int64_class;
      D.31061 = mono_array_new (domain, D.31060, 4);
      mono_gc_wbarrier_generic_store (data, D.31061);
      D.31062 = mono_defaults.string_class;
      D.31063 = mono_array_new (domain, D.31062, 2);
      mono_gc_wbarrier_generic_store (names, D.31063);
      memset (&start, 0, 44);
      start.tm_mday = 1;
      D.31064 = year + 4294965396;
      D.31065 = (int) D.31064;
      start.tm_year = D.31065;
      t.272 = mktime (&start);
      t = t.272;
      D.31069 = year + 4294965326;
      if (D.31069 > 67) goto <D.31067>; else goto <D.31070>;
      <D.31070>:
      t.273 = t;
      if (t.273 == -1) goto <D.31067>; else goto <D.31068>;
      <D.31067>:
      t.274 = time (0B);
      t = t.274;
      D.31073 = localtime (&t);
      tt = *D.31073;
      strftime (&tzone, 64, "%Z", &tt);
      {
        void * * __p;

        D.31074 = *names;
        __p = mono_array_addr_with_size (D.31074, 4, 0);
        D.31075 = mono_string_new (domain, &tzone);
        D.31074 = *names;
        mono_gc_wbarrier_set_arrayref (D.31074, __p, D.31075);
      }
      {
        void * * __p;

        D.31074 = *names;
        __p = mono_array_addr_with_size (D.31074, 4, 1);
        D.31076 = mono_string_new (domain, &tzone);
        D.31074 = *names;
        mono_gc_wbarrier_set_arrayref (D.31074, __p, D.31076);
      }
      D.31077 = 1;
      return D.31077;
      <D.31068>:
      t.273 = t;
      gmtoff = gmt_offset (&start, t.273);
      day = 0;
      goto <D.22765>;
      <D.22764>:
      t.273 = t;
      t.275 = t.273 + 86400;
      t = t.275;
      D.31079 = localtime (&t);
      tt = *D.31079;
      t.273 = t;
      gmtoff_after = gmt_offset (&tt, t.273);
      if (gmtoff_after != gmtoff) goto <D.31080>; else goto <D.31081>;
      <D.31080>:
      {
        struct tm tt1;
        time_t t1;

        try
          {
            t.273 = t;
            t1 = t.273;
            <D.22753>:
            t1.276 = t1;
            t1.277 = t1.276 + -3600;
            t1 = t1.277;
            D.31084 = localtime (&t1);
            tt1 = *D.31084;
            t1.276 = t1;
            D.31085 = gmt_offset (&tt1, t1.276);
            if (D.31085 != gmtoff) goto <D.22753>; else goto <D.22754>;
            <D.22754>:
            <D.22755>:
            t1.276 = t1;
            t1.278 = t1.276 + 60;
            t1 = t1.278;
            D.31087 = localtime (&t1);
            tt1 = *D.31087;
            t1.276 = t1;
            D.31088 = gmt_offset (&tt1, t1.276);
            if (D.31088 == gmtoff) goto <D.22755>; else goto <D.22756>;
            <D.22756>:
            t1.276 = t1;
            t1.279 = t1.276 + gmtoff;
            t1 = t1.279;
            strftime (&tzone, 64, "%Z", &tt);
            D.31090 = tt.tm_isdst;
            if (D.31090 != 0) goto <D.31091>; else goto <D.31092>;
            <D.31091>:
            {
              void * * __p;

              D.31074 = *names;
              __p = mono_array_addr_with_size (D.31074, 4, 1);
              D.31093 = mono_string_new (domain, &tzone);
              D.31074 = *names;
              mono_gc_wbarrier_set_arrayref (D.31074, __p, D.31093);
            }
            {
              gint64 * __p;

              D.31094 = *data;
              __p = mono_array_addr_with_size (D.31094, 8, 0);
              t1.276 = t1;
              D.31095 = (long long unsigned int) t1.276;
              D.31096 = D.31095 * 10000000;
              D.31097 = D.31096 + 621355968000000000;
              D.31098 = (long long int) D.31097;
              *__p = D.31098;
            }
            if (gmtoff_ds == 0) goto <D.31099>; else goto <D.31100>;
            <D.31099>:
            gmtoff_st = gmtoff;
            gmtoff_ds = gmtoff_after;
            <D.31100>:
            transitioned = transitioned + 1;
            goto <D.31101>;
            <D.31092>:
            {
              time_t te;

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

                D.31074 = *names;
                __p = mono_array_addr_with_size (D.31074, 4, 0);
                D.31102 = mono_string_new (domain, &tzone);
                D.31074 = *names;
                mono_gc_wbarrier_set_arrayref (D.31074, __p, D.31102);
              }
              {
                gint64 * __p;

                D.31094 = *data;
                __p = mono_array_addr_with_size (D.31094, 8, 1);
                t1.276 = t1;
                D.31095 = (long long unsigned int) t1.276;
                D.31096 = D.31095 * 10000000;
                D.31097 = D.31096 + 621355968000000000;
                D.31098 = (long long int) D.31097;
                *__p = D.31098;
              }
              if (gmtoff_ds == 0) goto <D.31103>; else goto <D.31104>;
              <D.31103>:
              gmtoff_st = gmtoff_after;
              gmtoff_ds = gmtoff;
              <D.31104>:
              transitioned = transitioned + 1;
            }
            <D.31101>:
            D.31105 = tt1.tm_isdst;
            if (D.31105 != 0) goto <D.31106>; else goto <D.31107>;
            <D.31106>:
            {
              gint64 * __p;

              D.31094 = *data;
              __p = mono_array_addr_with_size (D.31094, 8, 2);
              D.31108 = (long long int) gmtoff_st;
              D.31109 = D.31108 * 10000000;
              *__p = D.31109;
            }
            {
              gint64 * __p;

              D.31094 = *data;
              __p = mono_array_addr_with_size (D.31094, 8, 3);
              D.31110 = gmtoff_ds - gmtoff_st;
              D.31111 = (long long int) D.31110;
              D.31112 = D.31111 * 10000000;
              *__p = D.31112;
            }
            <D.31107>:
            t.273 = t;
            gmtoff = gmt_offset (&tt, t.273);
          }
        finally
          {
            tt1 = {CLOBBER};
            t1 = {CLOBBER};
          }
      }
      <D.31081>:
      day = day + 1;
      <D.22765>:
      D.31113 = day <= 364;
      D.31114 = transitioned <= 1;
      D.31115 = D.31113 & D.31114;
      if (D.31115 != 0) goto <D.22764>; else goto <D.22766>;
      <D.22766>:
      if (transitioned <= 1) goto <D.31116>; else goto <D.31117>;
      <D.31116>:
      strftime (&tzone, 64, "%Z", &tt);
      {
        void * * __p;

        D.31074 = *names;
        __p = mono_array_addr_with_size (D.31074, 4, 0);
        D.31118 = mono_string_new (domain, &tzone);
        D.31074 = *names;
        mono_gc_wbarrier_set_arrayref (D.31074, __p, D.31118);
      }
      {
        void * * __p;

        D.31074 = *names;
        __p = mono_array_addr_with_size (D.31074, 4, 1);
        D.31119 = mono_string_new (domain, &tzone);
        D.31074 = *names;
        mono_gc_wbarrier_set_arrayref (D.31074, __p, D.31119);
      }
      {
        gint64 * __p;

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

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

        D.31094 = *data;
        __p = mono_array_addr_with_size (D.31094, 8, 2);
        D.31120 = (long long int) gmtoff;
        D.31121 = D.31120 * 10000000;
        *__p = D.31121;
      }
      {
        gint64 * __p;

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


gmt_offset (struct tm * tm, time_t t)
{
  int D.31124;

  D.31124 = tm->tm_gmtoff;
  return D.31124;
}


InternalFromBase64String (struct MonoString * str, MonoBoolean allowWhitespaceOnly)
{
  struct MonoArray * D.31126;
  int D.31127;
  int D.31128;
  mono_unichar2 * D.31129;

  D.31127 = (int) allowWhitespaceOnly;
  D.31128 = mono_string_length (str);
  D.31129 = mono_string_chars (str);
  D.31126 = base64_to_byte_array (D.31129, D.31128, D.31127);
  return D.31126;
}


base64_to_byte_array (gunichar2 * start, gint ilength, MonoBoolean allowWhitespaceOnly)
{
  unsigned int i.280;
  unsigned int D.31132;
  gunichar2 * D.31133;
  struct MonoImage * D.31136;
  const short unsigned int * * D.31138;
  const short unsigned int * D.31139;
  unsigned int D.31140;
  unsigned int D.31141;
  const short unsigned int * D.31142;
  short unsigned int D.31143;
  int D.31144;
  int D.31145;
  _Bool D.31149;
  _Bool D.31150;
  _Bool D.31151;
  struct MonoImage * D.31154;
  _Bool D.31158;
  _Bool D.31159;
  _Bool D.31160;
  struct MonoArray * D.31163;
  struct MonoClass * D.31164;
  struct MonoDomain * D.31165;
  int D.31168;
  struct MonoImage * D.31170;
  struct MonoImage * D.31173;
  int D.31174;
  unsigned int olength.281;
  struct MonoDomain * D.31180;
  int i.282;
  unsigned int i.283;
  unsigned int D.31183;
  gunichar2 * D.31184;
  unsigned char D.31187;
  int D.31188;
  int D.31189;
  unsigned char D.31190;
  int D.31191;
  int D.31192;
  int D.31193;
  struct MonoImage * D.31196;
  _Bool D.31197;
  _Bool D.31198;
  _Bool D.31199;
  guchar * res_ptr.284;
  int D.31201;
  int D.31202;
  signed char D.31203;
  int D.31204;
  int D.31205;
  signed char D.31206;
  signed char D.31207;
  unsigned char D.31208;
  int D.31209;
  guchar * res_ptr.285;
  int D.31213;
  signed char D.31214;
  int D.31215;
  int D.31216;
  signed char D.31217;
  signed char D.31218;
  unsigned char D.31219;
  int D.31220;
  guchar * res_ptr.286;
  int D.31224;
  signed char D.31225;
  int D.31226;
  signed char D.31227;
  signed char D.31228;
  unsigned char D.31229;
  short unsigned int D.31231;
  unsigned int D.31232;
  unsigned int D.31233;
  const short unsigned int * D.31234;
  short unsigned int D.31235;
  int D.31236;
  int D.31237;
  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.23277>;
      <D.23276>:
      i.280 = (unsigned int) i;
      D.31132 = i.280 * 2;
      D.31133 = start + D.31132;
      c = *D.31133;
      if (c > 122) goto <D.31134>; else goto <D.31135>;
      <D.31134>:
      D.31136 = mono_get_corlib ();
      exc = mono_exception_from_name_msg (D.31136, "System", "FormatException", "Invalid character found.");
      mono_raise_exception (exc);
      goto <D.31137>;
      <D.31135>:
      D.31138 = __ctype_b_loc ();
      D.31139 = *D.31138;
      D.31140 = (unsigned int) c;
      D.31141 = D.31140 * 2;
      D.31142 = D.31139 + D.31141;
      D.31143 = *D.31142;
      D.31144 = (int) D.31143;
      D.31145 = D.31144 & 8192;
      if (D.31145 != 0) goto <D.31146>; else goto <D.31147>;
      <D.31146>:
      ignored = ignored + 1;
      goto <D.31148>;
      <D.31147>:
      D.31149 = havePadding != 0;
      D.31150 = c != 61;
      D.31151 = D.31149 & D.31150;
      if (D.31151 != 0) goto <D.31152>; else goto <D.31153>;
      <D.31152>:
      D.31154 = mono_get_corlib ();
      exc = mono_exception_from_name_msg (D.31154, "System", "FormatException", "Invalid character found.");
      mono_raise_exception (exc);
      goto <D.31155>;
      <D.31153>:
      if (c == 61) goto <D.31156>; else goto <D.31157>;
      <D.31156>:
      havePadding = 1;
      <D.31157>:
      prev2_last = prev_last;
      prev_last = last;
      last = c;
      <D.31155>:
      <D.31148>:
      <D.31137>:
      i = i + 1;
      <D.23277>:
      if (i < ilength) goto <D.23276>; else goto <D.23278>;
      <D.23278>:
      olength = ilength - ignored;
      D.31158 = allowWhitespaceOnly != 0;
      D.31159 = olength == 0;
      D.31160 = D.31158 & D.31159;
      if (D.31160 != 0) goto <D.31161>; else goto <D.31162>;
      <D.31161>:
      D.31164 = mono_defaults.byte_class;
      D.31165 = mono_domain_get ();
      D.31163 = mono_array_new (D.31165, D.31164, 0);
      return D.31163;
      <D.31162>:
      D.31168 = olength & 3;
      if (D.31168 != 0) goto <D.31166>; else goto <D.31169>;
      <D.31169>:
      if (olength <= 0) goto <D.31166>; else goto <D.31167>;
      <D.31166>:
      D.31170 = mono_get_corlib ();
      exc = mono_exception_from_name_msg (D.31170, "System", "FormatException", "Invalid length.");
      mono_raise_exception (exc);
      <D.31167>:
      if (prev2_last == 61) goto <D.31171>; else goto <D.31172>;
      <D.31171>:
      D.31173 = mono_get_corlib ();
      exc = mono_exception_from_name_msg (D.31173, "System", "FormatException", "Invalid format.");
      mono_raise_exception (exc);
      <D.31172>:
      D.31174 = olength * 3;
      olength = D.31174 / 4;
      if (last == 61) goto <D.31175>; else goto <D.31176>;
      <D.31175>:
      olength = olength + -1;
      <D.31176>:
      if (prev_last == 61) goto <D.31177>; else goto <D.31178>;
      <D.31177>:
      olength = olength + -1;
      <D.31178>:
      olength.281 = (unsigned int) olength;
      D.31164 = mono_defaults.byte_class;
      D.31180 = mono_domain_get ();
      result = mono_array_new (D.31180, D.31164, olength.281);
      res_ptr = mono_array_addr_with_size (result, 1, 0);
      i = 0;
      goto <D.23287>;
      <D.23286>:
      {
        int k;

        k = 0;
        goto <D.23280>;
        <D.23281>:
        i.282 = i;
        i = i.282 + 1;
        i.283 = (unsigned int) i.282;
        D.31183 = i.283 * 2;
        D.31184 = start + D.31183;
        c = *D.31184;
        D.31138 = __ctype_b_loc ();
        D.31139 = *D.31138;
        D.31140 = (unsigned int) c;
        D.31141 = D.31140 * 2;
        D.31142 = D.31139 + D.31141;
        D.31143 = *D.31142;
        D.31144 = (int) D.31143;
        D.31145 = D.31144 & 8192;
        if (D.31145 != 0) goto <D.31185>; else goto <D.31186>;
        <D.31185>:
        // predicted unlikely by continue predictor.
        goto <D.23280>;
        <D.31186>:
        D.31187 = (unsigned char) c;
        D.31188 = (int) D.31187;
        a[k] = D.31188;
        D.31189 = (int) c;
        D.31190 = dbase64[D.31189];
        D.31191 = (int) D.31190;
        b[k] = D.31191;
        D.31192 = b[k];
        D.31193 = D.31192 & 128;
        if (D.31193 != 0) goto <D.31194>; else goto <D.31195>;
        <D.31194>:
        D.31196 = mono_get_corlib ();
        exc = mono_exception_from_name_msg (D.31196, "System", "FormatException", "Invalid character found.");
        mono_raise_exception (exc);
        <D.31195>:
        k = k + 1;
        <D.23280>:
        D.31197 = k <= 3;
        D.31198 = i < ilength;
        D.31199 = D.31197 & D.31198;
        if (D.31199 != 0) goto <D.23281>; else goto <D.23282>;
        <D.23282>:
        res_ptr.284 = res_ptr;
        res_ptr = res_ptr.284 + 1;
        D.31201 = b[0];
        D.31202 = D.31201 << 2;
        D.31203 = (signed char) D.31202;
        D.31204 = b[1];
        D.31205 = D.31204 >> 4;
        D.31206 = (signed char) D.31205;
        D.31207 = D.31203 | D.31206;
        D.31208 = (unsigned char) D.31207;
        *res_ptr.284 = D.31208;
        D.31209 = a[2];
        if (D.31209 != 61) goto <D.31210>; else goto <D.31211>;
        <D.31210>:
        res_ptr.285 = res_ptr;
        res_ptr = res_ptr.285 + 1;
        D.31204 = b[1];
        D.31213 = D.31204 << 4;
        D.31214 = (signed char) D.31213;
        D.31215 = b[2];
        D.31216 = D.31215 >> 2;
        D.31217 = (signed char) D.31216;
        D.31218 = D.31214 | D.31217;
        D.31219 = (unsigned char) D.31218;
        *res_ptr.285 = D.31219;
        <D.31211>:
        D.31220 = a[3];
        if (D.31220 != 61) goto <D.31221>; else goto <D.31222>;
        <D.31221>:
        res_ptr.286 = res_ptr;
        res_ptr = res_ptr.286 + 1;
        D.31215 = b[2];
        D.31224 = D.31215 << 6;
        D.31225 = (signed char) D.31224;
        D.31226 = b[3];
        D.31227 = (signed char) D.31226;
        D.31228 = D.31225 | D.31227;
        D.31229 = (unsigned char) D.31228;
        *res_ptr.286 = D.31229;
        <D.31222>:
        goto <D.23284>;
        <D.23283>:
        i = i + 1;
        <D.23284>:
        if (i < ilength) goto <D.31230>; else goto <D.23285>;
        <D.31230>:
        D.31138 = __ctype_b_loc ();
        D.31139 = *D.31138;
        i.280 = (unsigned int) i;
        D.31132 = i.280 * 2;
        D.31133 = start + D.31132;
        D.31231 = *D.31133;
        D.31232 = (unsigned int) D.31231;
        D.31233 = D.31232 * 2;
        D.31234 = D.31139 + D.31233;
        D.31235 = *D.31234;
        D.31236 = (int) D.31235;
        D.31237 = D.31236 & 8192;
        if (D.31237 != 0) goto <D.23283>; else goto <D.23285>;
        <D.23285>:
      }
      <D.23287>:
      if (i < ilength) goto <D.23286>; else goto <D.23288>;
      <D.23288>:
      D.31163 = result;
      return D.31163;
    }
  finally
    {
      a = {CLOBBER};
      b = {CLOBBER};
    }
}


InternalFromBase64CharArray (struct MonoArray * input, gint offset, gint length)
{
  struct MonoArray * D.31240;
  unsigned int offset.287;
  char * D.31242;

  offset.287 = (unsigned int) offset;
  D.31242 = mono_array_addr_with_size (input, 2, offset.287);
  D.31240 = base64_to_byte_array (D.31242, length, 0);
  return D.31240;
}


get_bundled_app_config ()
{
  struct MonoAppDomainSetup * D.31244;
  struct MonoString * D.31247;
  unsigned int D.31250;
  unsigned int D.31251;
  struct MonoDomain * D.31256;
  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.31244 = domain->setup;
  file = D.31244->configuration_file;
  if (file == 0B) goto <D.31245>; else goto <D.31246>;
  <D.31245>:
  D.31247 = 0B;
  return D.31247;
  <D.31246>:
  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.31248>; else goto <D.31249>;
  <D.31248>:
  config_file_path = config_file_name;
  <D.31249>:
  D.31250 = strlen (config_file_path);
  len = D.31250 + 4294967289;
  D.31251 = len + 1;
  module = monoeg_malloc0 (D.31251);
  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.31252>; else goto <D.31253>;
  <D.31252>:
  monoeg_g_free (config_file_name);
  <D.31253>:
  monoeg_g_free (config_file_path);
  if (app_config == 0B) goto <D.31254>; else goto <D.31255>;
  <D.31254>:
  D.31247 = 0B;
  return D.31247;
  <D.31255>:
  D.31256 = mono_domain_get ();
  D.31247 = mono_string_new (D.31256, app_config);
  return D.31247;
}


ves_icall_System_Configuration_DefaultConfig_get_machine_config_path ()
{
  const struct MonoRuntimeInfo * D.31258;
  const char[4] * D.31259;
  const char * D.31260;
  struct MonoDomain * D.31261;
  struct MonoString * D.31262;
  struct MonoString * mcpath;
  gchar * path;

  D.31258 = mono_get_runtime_info ();
  D.31259 = &D.31258->framework_version;
  D.31260 = mono_get_config_dir ();
  path = monoeg_g_build_path ("/", D.31260, "mono", D.31259, "machine.config", 0B);
  D.31261 = mono_domain_get ();
  mcpath = mono_string_new (D.31261, path);
  monoeg_g_free (path);
  D.31262 = mcpath;
  return D.31262;
}


get_bundled_machine_config ()
{
  struct MonoString * D.31266;
  struct MonoDomain * D.31267;
  const gchar * machine_config;

  machine_config = mono_get_machine_config ();
  if (machine_config == 0B) goto <D.31264>; else goto <D.31265>;
  <D.31264>:
  D.31266 = 0B;
  return D.31266;
  <D.31265>:
  D.31267 = mono_domain_get ();
  D.31266 = mono_string_new (D.31267, machine_config);
  return D.31266;
}


ves_icall_System_ComponentModel_Win32Exception_W32ErrorMessage (guint32 code)
{
  struct MonoDomain * D.31271;
  int ret.288;
  struct MonoDomain * D.31274;
  struct MonoString * D.31275;
  struct MonoString * message;
  guint32 ret;
  gunichar2 buf[256];

  try
    {
      ret = FormatMessage (4608, 0B, code, 0, &buf, 255, 0B);
      if (ret == 0) goto <D.31269>; else goto <D.31270>;
      <D.31269>:
      D.31271 = mono_domain_get ();
      message = mono_string_new (D.31271, "Error looking up error string");
      goto <D.31272>;
      <D.31270>:
      ret.288 = (int) ret;
      D.31274 = mono_domain_get ();
      message = mono_string_new_utf16 (D.31274, &buf, ret.288);
      <D.31272>:
      D.31275 = message;
      return D.31275;
    }
  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.31278>; else goto <D.31279>;
  <D.31278>:
  *category_data = &CategoryData_v4;
  *category_astral_index = &CategoryData_v4_astral_index;
  return;
  <D.31279>:
  *category_data = &CategoryData_v2;
  *category_astral_index = &CategoryData_v2_astral_index;
}


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

  {
    gint8 * __p;

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


ves_icall_System_Buffer_GetByteInternal (struct MonoArray * array, gint32 idx)
{
  gint8 D.31282;
  unsigned int idx.290;
  char * D.31284;

  idx.290 = (unsigned int) idx;
  D.31284 = mono_array_addr_with_size (array, 1, idx.290);
  D.31282 = MEM[(gint8 *)D.31284];
  return D.31282;
}


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

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


mono_array_get_byte_length (struct MonoArray * array)
{
  struct MonoVTable * D.31288;
  struct MonoArrayBounds * D.31289;
  unsigned int D.31292;
  unsigned int i.291;
  unsigned int D.31295;
  struct MonoArrayBounds * D.31296;
  unsigned int D.31297;
  unsigned int length.292;
  unsigned int D.31299;
  unsigned char D.31300;
  int D.31301;
  struct MonoClass * D.31302;
  unsigned char D.31303;
  int D.31304;
  gint32 D.31305;
  unsigned int length.293;
  unsigned int D.31307;
  struct MonoClass * klass;
  int length;
  int i;

  D.31288 = array->obj.vtable;
  klass = D.31288->klass;
  D.31289 = array->bounds;
  if (D.31289 == 0B) goto <D.31290>; else goto <D.31291>;
  <D.31290>:
  D.31292 = array->max_length;
  length = (int) D.31292;
  goto <D.31293>;
  <D.31291>:
  length = 1;
  i = 0;
  goto <D.22783>;
  <D.22782>:
  D.31289 = array->bounds;
  i.291 = (unsigned int) i;
  D.31295 = i.291 * 8;
  D.31296 = D.31289 + D.31295;
  D.31297 = D.31296->length;
  length.292 = (unsigned int) length;
  D.31299 = D.31297 * length.292;
  length = (int) D.31299;
  i = i + 1;
  <D.22783>:
  D.31300 = klass->rank;
  D.31301 = (int) D.31300;
  if (D.31301 > i) goto <D.22782>; else goto <D.22784>;
  <D.22784>:
  <D.31293>:
  D.31302 = klass->element_class;
  D.31303 = D.31302->byval_arg.type;
  D.31304 = (int) D.31303;
  switch (D.31304) <default: <D.22799>, case 2: <D.22787>, case 3: <D.22790>, case 4: <D.22785>, case 5: <D.22786>, case 6: <D.22788>, case 7: <D.22789>, case 8: <D.22791>, case 9: <D.22792>, case 10: <D.22796>, case 11: <D.22797>, case 12: <D.22793>, case 13: <D.22798>, case 24: <D.22794>, case 25: <D.22795>>
  <D.22785>:
  <D.22786>:
  <D.22787>:
  D.31305 = length;
  return D.31305;
  <D.22788>:
  <D.22789>:
  <D.22790>:
  D.31305 = length << 1;
  return D.31305;
  <D.22791>:
  <D.22792>:
  <D.22793>:
  D.31305 = length << 2;
  return D.31305;
  <D.22794>:
  <D.22795>:
  length.293 = (unsigned int) length;
  D.31307 = length.293 * 4;
  D.31305 = (gint32) D.31307;
  return D.31305;
  <D.22796>:
  <D.22797>:
  <D.22798>:
  D.31305 = length << 3;
  return D.31305;
  <D.22799>:
  D.31305 = -1;
  return D.31305;
}


ves_icall_System_Buffer_BlockCopyInternal (struct MonoArray * src, gint32 src_offset, struct MonoArray * dest, gint32 dest_offset, gint32 count)
{
  _Bool D.31309;
  long int D.31310;
  long int D.31311;
  _Bool D.31316;
  long int D.31317;
  long int D.31318;
  int D.31325;
  int D.31326;
  int D.31328;
  int D.31329;
  MonoBoolean D.31330;
  double[0:] * D.31331;
  sizetype src_offset.294;
  double[0:] * D.31333;
  sizetype dest_offset.295;
  unsigned int count.296;
  guint8 * src_buf;
  guint8 * dest_buf;

  D.31309 = src == 0B;
  D.31310 = (long int) D.31309;
  D.31311 = __builtin_expect (D.31310, 0);
  if (D.31311 != 0) goto <D.31312>; else goto <D.31313>;
  <D.31312>:
  {
    struct MonoException * ex;

    if (src != 0B) goto <D.31314>; else goto <D.31315>;
    <D.31314>:
    <D.31315>:
    ex = mono_get_exception_argument_null ("src");
    mono_raise_exception (ex);
  }
  <D.31313>:
  D.31316 = dest == 0B;
  D.31317 = (long int) D.31316;
  D.31318 = __builtin_expect (D.31317, 0);
  if (D.31318 != 0) goto <D.31319>; else goto <D.31320>;
  <D.31319>:
  {
    struct MonoException * ex;

    if (dest != 0B) goto <D.31321>; else goto <D.31322>;
    <D.31321>:
    <D.31322>:
    ex = mono_get_exception_argument_null ("dest");
    mono_raise_exception (ex);
  }
  <D.31320>:
  D.31325 = mono_array_get_byte_length (src);
  D.31326 = D.31325 - count;
  if (D.31326 < src_offset) goto <D.31323>; else goto <D.31327>;
  <D.31327>:
  D.31328 = mono_array_get_byte_length (dest);
  D.31329 = D.31328 - count;
  if (D.31329 < dest_offset) goto <D.31323>; else goto <D.31324>;
  <D.31323>:
  D.31330 = 0;
  return D.31330;
  <D.31324>:
  D.31331 = &src->vector;
  src_offset.294 = (sizetype) src_offset;
  src_buf = D.31331 + src_offset.294;
  D.31333 = &dest->vector;
  dest_offset.295 = (sizetype) dest_offset;
  dest_buf = D.31333 + dest_offset.295;
  if (src != dest) goto <D.31335>; else goto <D.31336>;
  <D.31335>:
  count.296 = (unsigned int) count;
  memcpy (dest_buf, src_buf, count.296);
  goto <D.31338>;
  <D.31336>:
  count.296 = (unsigned int) count;
  memmove (dest_buf, src_buf, count.296);
  <D.31338>:
  D.31330 = 1;
  return D.31330;
}


memmove (void * __dest, const void * __src, size_t __len)
{
  void * D.31340;
  unsigned int D.31341;

  D.31341 = __builtin_object_size (__dest, 0);
  D.31340 = __builtin___memmove_chk (__dest, __src, __len, D.31341);
  return D.31340;
}


ves_icall_System_Array_SetValueImpl (struct MonoArray * this, struct MonoObject * value, guint32 pos)
{
  struct MonoVTable * D.31345;
  struct MonoVTable * D.31347;
  double[0:] * D.31348;
  unsigned int esize.297;
  unsigned int D.31350;
  int D.31351;
  unsigned int esize.298;
  unsigned char D.31357;
  int D.31358;
  unsigned char D.31359;
  int D.31360;
  struct MonoRuntimeCallbacks * D.31361;
  void (*<T26f6>) (struct MonoClass *, struct MonoClass *) D.31362;
  struct MonoException * D.31363;
  struct MonoException * D.31364;
  struct MonoRuntimeCallbacks * D.31365;
  void (*<T26f6>) (struct MonoClass *, struct MonoClass *) D.31366;
  struct MonoException * D.31367;
  unsigned char D.31369;
  unsigned char D.31370;
  struct MonoObject * D.31373;
  struct MonoRuntimeCallbacks * D.31376;
  void (*<T26f6>) (struct MonoClass *, struct MonoClass *) D.31377;
  struct MonoException * D.31378;
  struct MonoObject * D.31379;
  unsigned char D.31382;
  unsigned char D.31383;
  void * D.31386;
  const void * D.31388;
  unsigned char D.31389;
  unsigned char D.31390;
  struct MonoRuntimeCallbacks * D.31393;
  void (*<T26f6>) (struct MonoClass *, struct MonoClass *) D.31394;
  struct MonoException * D.31395;
  int D.31396;
  unsigned int D.31397;
  unsigned int D.31398;
  struct MonoClass * D.31401;
  unsigned char D.31402;
  unsigned char D.31403;
  struct MonoType * D.31406;
  unsigned char D.31407;
  struct MonoClass * D.31410;
  unsigned char D.31411;
  unsigned char D.31412;
  struct MonoType * D.31415;
  unsigned char D.31416;
  unsigned char D.31417;
  short unsigned int D.31418;
  unsigned int D.31419;
  signed char D.31420;
  short int D.31421;
  int D.31422;
  float D.31423;
  struct MonoException * D.31424;
  struct MonoRuntimeCallbacks * D.31425;
  void (*<T26f6>) (struct MonoClass *, struct MonoClass *) D.31426;
  struct MonoException * D.31427;
  struct MonoException * D.31431;
  short unsigned int D.31432;
  struct MonoException * D.31433;
  struct MonoException * D.31437;
  unsigned char D.31438;
  struct MonoException * D.31439;
  struct MonoException * D.31443;
  struct MonoException * D.31444;
  struct MonoException * D.31448;
  unsigned int D.31449;
  struct MonoException * D.31450;
  struct MonoException * D.31454;
  struct MonoException * D.31455;
  struct MonoException * D.31459;
  signed char D.31460;
  struct MonoException * D.31463;
  signed char D.31464;
  struct MonoException * D.31465;
  struct MonoException * D.31469;
  short int D.31470;
  struct MonoException * D.31473;
  short int D.31474;
  struct MonoException * D.31475;
  struct MonoException * D.31479;
  int D.31480;
  struct MonoException * D.31483;
  int D.31484;
  struct MonoException * D.31485;
  struct MonoException * D.31489;
  struct MonoException * D.31492;
  long long int u64.299;
  struct MonoException * D.31494;
  struct MonoException * D.31498;
  float D.31499;
  float D.31500;
  float D.31501;
  struct MonoException * D.31505;
  double D.31506;
  double D.31507;
  struct MonoRuntimeCallbacks * D.31510;
  void (*<T26f6>) (struct MonoClass *, struct MonoClass *) D.31511;
  struct MonoException * D.31512;
  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.31343>; else goto <D.31344>;
  <D.31343>:
  D.31345 = value->vtable;
  vc = D.31345->klass;
  goto <D.31346>;
  <D.31344>:
  vc = 0B;
  <D.31346>:
  D.31347 = this->obj.vtable;
  ac = D.31347->klass;
  ec = ac->element_class;
  esize = mono_array_element_size (ac);
  D.31348 = &this->vector;
  esize.297 = (unsigned int) esize;
  D.31350 = pos * esize.297;
  ea = D.31348 + D.31350;
  va = value + 8;
  D.31351 = mono_class_is_nullable (ec);
  if (D.31351 != 0) goto <D.31352>; else goto <D.31353>;
  <D.31352>:
  mono_nullable_init (ea, value, ec);
  return;
  <D.31353>:
  if (value == 0B) goto <D.31354>; else goto <D.31355>;
  <D.31354>:
  esize.298 = (unsigned int) esize;
  mono_gc_bzero_atomic (ea, esize.298);
  return;
  <D.31355>:
  D.31357 = ec->byval_arg.type;
  D.31358 = (int) D.31357;
  switch (D.31358) <default: <D.31368>, case 2: <D.20377>, case 14: <D.20372>>
  <D.20372>:
  D.31359 = vc->byval_arg.type;
  D.31360 = (int) D.31359;
  switch (D.31360) <default: <D.20375>, case 14: <D.20373>>
  <D.20373>:
  goto <D.20374>;
  <D.20375>:
  D.31361 = mono_get_runtime_callbacks ();
  D.31362 = D.31361->set_cast_details;
  D.31362 (vc, ec);
  D.31363 = mono_get_exception_invalid_cast ();
  mono_raise_exception (D.31363);
  <D.20374>:
  goto <D.20376>;
  <D.20377>:
  D.31359 = vc->byval_arg.type;
  D.31360 = (int) D.31359;
  switch (D.31360) <default: <D.20391>, case 2: <D.20378>, case 3: <D.20380>, case 4: <D.20385>, case 5: <D.20381>, case 6: <D.20386>, case 7: <D.20382>, case 8: <D.20387>, case 9: <D.20383>, case 10: <D.20388>, case 11: <D.20384>, case 12: <D.20389>, case 13: <D.20390>>
  <D.20378>:
  goto <D.20379>;
  <D.20380>:
  <D.20381>:
  <D.20382>:
  <D.20383>:
  <D.20384>:
  <D.20385>:
  <D.20386>:
  <D.20387>:
  <D.20388>:
  <D.20389>:
  <D.20390>:
  D.31364 = mono_get_exception_argument ("value", "not a widening conversion");
  mono_raise_exception (D.31364);
  <D.20391>:
  D.31365 = mono_get_runtime_callbacks ();
  D.31366 = D.31365->set_cast_details;
  D.31366 (vc, ec);
  D.31367 = mono_get_exception_invalid_cast ();
  mono_raise_exception (D.31367);
  <D.20379>:
  goto <D.20376>;
  <D.31368>:
  <D.20376>:
  D.31369 = BIT_FIELD_REF <*ec, 8, 160>;
  D.31370 = D.31369 & 8;
  if (D.31370 == 0) goto <D.31371>; else goto <D.31372>;
  <D.31371>:
  D.31373 = mono_object_isinst (value, ec);
  if (D.31373 == 0B) goto <D.31374>; else goto <D.31375>;
  <D.31374>:
  D.31376 = mono_get_runtime_callbacks ();
  D.31377 = D.31376->set_cast_details;
  D.31377 (vc, ec);
  D.31378 = mono_get_exception_invalid_cast ();
  mono_raise_exception (D.31378);
  <D.31375>:
  mono_gc_wbarrier_set_arrayref (this, ea, value);
  return;
  <D.31372>:
  D.31379 = mono_object_isinst (value, ec);
  if (D.31379 != 0B) goto <D.31380>; else goto <D.31381>;
  <D.31380>:
  D.31382 = BIT_FIELD_REF <*ec, 8, 184>;
  D.31383 = D.31382 & 8;
  if (D.31383 != 0) goto <D.31384>; else goto <D.31385>;
  <D.31384>:
  D.31386 = value + 8;
  mono_value_copy (ea, D.31386, ec);
  goto <D.31387>;
  <D.31385>:
  esize.298 = (unsigned int) esize;
  D.31388 = value + 8;
  mono_gc_memmove_atomic (ea, D.31388, esize.298);
  <D.31387>:
  return;
  <D.31381>:
  D.31389 = BIT_FIELD_REF <*vc, 8, 160>;
  D.31390 = D.31389 & 8;
  if (D.31390 == 0) goto <D.31391>; else goto <D.31392>;
  <D.31391>:
  D.31393 = mono_get_runtime_callbacks ();
  D.31394 = D.31393->set_cast_details;
  D.31394 (vc, ec);
  D.31395 = mono_get_exception_invalid_cast ();
  mono_raise_exception (D.31395);
  <D.31392>:
  D.31396 = mono_class_instance_size (vc);
  D.31397 = (unsigned int) D.31396;
  D.31398 = D.31397 + 4294967288;
  vsize = (gint32) D.31398;
  D.31357 = ec->byval_arg.type;
  et = (int) D.31357;
  if (et == 17) goto <D.31399>; else goto <D.31400>;
  <D.31399>:
  D.31401 = ec->byval_arg.data.klass;
  D.31402 = BIT_FIELD_REF <*D.31401, 8, 160>;
  D.31403 = D.31402 & 16;
  if (D.31403 != 0) goto <D.31404>; else goto <D.31405>;
  <D.31404>:
  D.31401 = ec->byval_arg.data.klass;
  D.31406 = mono_class_enum_basetype (D.31401);
  D.31407 = D.31406->type;
  et = (int) D.31407;
  <D.31405>:
  <D.31400>:
  D.31359 = vc->byval_arg.type;
  vt = (int) D.31359;
  if (vt == 17) goto <D.31408>; else goto <D.31409>;
  <D.31408>:
  D.31410 = vc->byval_arg.data.klass;
  D.31411 = BIT_FIELD_REF <*D.31410, 8, 160>;
  D.31412 = D.31411 & 16;
  if (D.31412 != 0) goto <D.31413>; else goto <D.31414>;
  <D.31413>:
  D.31410 = vc->byval_arg.data.klass;
  D.31415 = mono_class_enum_basetype (D.31410);
  D.31416 = D.31415->type;
  vt = (int) D.31416;
  <D.31414>:
  <D.31409>:
  switch (vt) <default: <D.31428>, case 2: <D.20404>, case 3: <D.20403>, case 4: <D.20397>, case 5: <D.20392>, case 6: <D.20398>, case 7: <D.20394>, case 8: <D.20399>, case 9: <D.20395>, case 10: <D.20400>, case 11: <D.20396>, case 12: <D.20401>, case 13: <D.20402>>
  <D.20392>:
  D.31417 = MEM[(guint8 *)va];
  u64 = (guint64) D.31417;
  goto <D.20393>;
  <D.20394>:
  D.31418 = MEM[(guint16 *)va];
  u64 = (guint64) D.31418;
  goto <D.20393>;
  <D.20395>:
  D.31419 = MEM[(guint32 *)va];
  u64 = (guint64) D.31419;
  goto <D.20393>;
  <D.20396>:
  u64 = MEM[(guint64 *)va];
  goto <D.20393>;
  <D.20397>:
  D.31420 = MEM[(gint8 *)va];
  i64 = (gint64) D.31420;
  goto <D.20393>;
  <D.20398>:
  D.31421 = MEM[(gint16 *)va];
  i64 = (gint64) D.31421;
  goto <D.20393>;
  <D.20399>:
  D.31422 = MEM[(gint32 *)va];
  i64 = (gint64) D.31422;
  goto <D.20393>;
  <D.20400>:
  i64 = MEM[(gint64 *)va];
  goto <D.20393>;
  <D.20401>:
  D.31423 = MEM[(gfloat *)va];
  r64 = (gdouble) D.31423;
  goto <D.20393>;
  <D.20402>:
  r64 = MEM[(gdouble *)va];
  goto <D.20393>;
  <D.20403>:
  D.31418 = MEM[(guint16 *)va];
  u64 = (guint64) D.31418;
  goto <D.20393>;
  <D.20404>:
  switch (et) <default: <D.20416>, case 3: <D.20405>, case 4: <D.20410>, case 5: <D.20406>, case 6: <D.20411>, case 7: <D.20407>, case 8: <D.20412>, case 9: <D.20408>, case 10: <D.20413>, case 11: <D.20409>, case 12: <D.20414>, case 13: <D.20415>>
  <D.20405>:
  <D.20406>:
  <D.20407>:
  <D.20408>:
  <D.20409>:
  <D.20410>:
  <D.20411>:
  <D.20412>:
  <D.20413>:
  <D.20414>:
  <D.20415>:
  D.31424 = mono_get_exception_argument ("value", "not a widening conversion");
  mono_raise_exception (D.31424);
  <D.20416>:
  D.31425 = mono_get_runtime_callbacks ();
  D.31426 = D.31425->set_cast_details;
  D.31426 (vc, ec);
  D.31427 = mono_get_exception_invalid_cast ();
  mono_raise_exception (D.31427);
  goto <D.20393>;
  <D.31428>:
  <D.20393>:
  switch (et) <default: <D.31509>, case 3: <D.20417>, case 4: <D.20477>, case 5: <D.20429>, case 6: <D.20489>, case 7: <D.20441>, case 8: <D.20501>, case 9: <D.20453>, case 10: <D.20513>, case 11: <D.20465>, case 12: <D.20525>, case 13: <D.20537>>
  <D.20417>:
  switch (vt) <default: <D.31434>, case 3: <D.20422>, case 4: <D.20423>, case 5: <D.20418>, case 6: <D.20424>, case 7: <D.20419>, case 8: <D.20425>, case 9: <D.20420>, case 10: <D.20426>, case 11: <D.20421>, case 12: <D.20427>, case 13: <D.20428>>
  <D.20418>:
  <D.20419>:
  <D.20420>:
  <D.20421>:
  <D.20422>:
  if (esize < vsize) goto <D.31429>; else goto <D.31430>;
  <D.31429>:
  D.31431 = mono_get_exception_argument ("value", "not a widening conversion");
  mono_raise_exception (D.31431);
  <D.31430>:
  D.31432 = (short unsigned int) u64;
  MEM[(guint16 *)ea] = D.31432;
  return;
  <D.20423>:
  <D.20424>:
  <D.20425>:
  <D.20426>:
  <D.20427>:
  <D.20428>:
  D.31433 = mono_get_exception_argument ("value", "not a widening conversion");
  mono_raise_exception (D.31433);
  <D.31434>:
  <D.20429>:
  switch (vt) <default: <D.31440>, case 3: <D.20434>, case 4: <D.20435>, case 5: <D.20430>, case 6: <D.20436>, case 7: <D.20431>, case 8: <D.20437>, case 9: <D.20432>, case 10: <D.20438>, case 11: <D.20433>, case 12: <D.20439>, case 13: <D.20440>>
  <D.20430>:
  <D.20431>:
  <D.20432>:
  <D.20433>:
  <D.20434>:
  if (esize < vsize) goto <D.31435>; else goto <D.31436>;
  <D.31435>:
  D.31437 = mono_get_exception_argument ("value", "not a widening conversion");
  mono_raise_exception (D.31437);
  <D.31436>:
  D.31438 = (unsigned char) u64;
  MEM[(guint8 *)ea] = D.31438;
  return;
  <D.20435>:
  <D.20436>:
  <D.20437>:
  <D.20438>:
  <D.20439>:
  <D.20440>:
  D.31439 = mono_get_exception_argument ("value", "not a widening conversion");
  mono_raise_exception (D.31439);
  <D.31440>:
  <D.20441>:
  switch (vt) <default: <D.31445>, case 3: <D.20446>, case 4: <D.20447>, case 5: <D.20442>, case 6: <D.20448>, case 7: <D.20443>, case 8: <D.20449>, case 9: <D.20444>, case 10: <D.20450>, case 11: <D.20445>, case 12: <D.20451>, case 13: <D.20452>>
  <D.20442>:
  <D.20443>:
  <D.20444>:
  <D.20445>:
  <D.20446>:
  if (esize < vsize) goto <D.31441>; else goto <D.31442>;
  <D.31441>:
  D.31443 = mono_get_exception_argument ("value", "not a widening conversion");
  mono_raise_exception (D.31443);
  <D.31442>:
  D.31432 = (short unsigned int) u64;
  MEM[(guint16 *)ea] = D.31432;
  return;
  <D.20447>:
  <D.20448>:
  <D.20449>:
  <D.20450>:
  <D.20451>:
  <D.20452>:
  D.31444 = mono_get_exception_argument ("value", "not a widening conversion");
  mono_raise_exception (D.31444);
  <D.31445>:
  <D.20453>:
  switch (vt) <default: <D.31451>, case 3: <D.20458>, case 4: <D.20459>, case 5: <D.20454>, case 6: <D.20460>, case 7: <D.20455>, case 8: <D.20461>, case 9: <D.20456>, case 10: <D.20462>, case 11: <D.20457>, case 12: <D.20463>, case 13: <D.20464>>
  <D.20454>:
  <D.20455>:
  <D.20456>:
  <D.20457>:
  <D.20458>:
  if (esize < vsize) goto <D.31446>; else goto <D.31447>;
  <D.31446>:
  D.31448 = mono_get_exception_argument ("value", "not a widening conversion");
  mono_raise_exception (D.31448);
  <D.31447>:
  D.31449 = (unsigned int) u64;
  MEM[(guint32 *)ea] = D.31449;
  return;
  <D.20459>:
  <D.20460>:
  <D.20461>:
  <D.20462>:
  <D.20463>:
  <D.20464>:
  D.31450 = mono_get_exception_argument ("value", "not a widening conversion");
  mono_raise_exception (D.31450);
  <D.31451>:
  <D.20465>:
  switch (vt) <default: <D.31456>, case 3: <D.20470>, case 4: <D.20471>, case 5: <D.20466>, case 6: <D.20472>, case 7: <D.20467>, case 8: <D.20473>, case 9: <D.20468>, case 10: <D.20474>, case 11: <D.20469>, case 12: <D.20475>, case 13: <D.20476>>
  <D.20466>:
  <D.20467>:
  <D.20468>:
  <D.20469>:
  <D.20470>:
  if (esize < vsize) goto <D.31452>; else goto <D.31453>;
  <D.31452>:
  D.31454 = mono_get_exception_argument ("value", "not a widening conversion");
  mono_raise_exception (D.31454);
  <D.31453>:
  MEM[(guint64 *)ea] = u64;
  return;
  <D.20471>:
  <D.20472>:
  <D.20473>:
  <D.20474>:
  <D.20475>:
  <D.20476>:
  D.31455 = mono_get_exception_argument ("value", "not a widening conversion");
  mono_raise_exception (D.31455);
  <D.31456>:
  <D.20477>:
  switch (vt) <default: <D.31466>, case 3: <D.20486>, case 4: <D.20478>, case 5: <D.20482>, case 6: <D.20479>, case 7: <D.20483>, case 8: <D.20480>, case 9: <D.20484>, case 10: <D.20481>, case 11: <D.20485>, case 12: <D.20487>, case 13: <D.20488>>
  <D.20478>:
  <D.20479>:
  <D.20480>:
  <D.20481>:
  if (esize < vsize) goto <D.31457>; else goto <D.31458>;
  <D.31457>:
  D.31459 = mono_get_exception_argument ("value", "not a widening conversion");
  mono_raise_exception (D.31459);
  <D.31458>:
  D.31460 = (signed char) i64;
  MEM[(gint8 *)ea] = D.31460;
  return;
  <D.20482>:
  <D.20483>:
  <D.20484>:
  <D.20485>:
  <D.20486>:
  if (vsize >= esize) goto <D.31461>; else goto <D.31462>;
  <D.31461>:
  D.31463 = mono_get_exception_argument ("value", "not a widening conversion");
  mono_raise_exception (D.31463);
  <D.31462>:
  D.31464 = (signed char) u64;
  MEM[(gint8 *)ea] = D.31464;
  return;
  <D.20487>:
  <D.20488>:
  D.31465 = mono_get_exception_argument ("value", "not a widening conversion");
  mono_raise_exception (D.31465);
  <D.31466>:
  <D.20489>:
  switch (vt) <default: <D.31476>, case 3: <D.20498>, case 4: <D.20490>, case 5: <D.20494>, case 6: <D.20491>, case 7: <D.20495>, case 8: <D.20492>, case 9: <D.20496>, case 10: <D.20493>, case 11: <D.20497>, case 12: <D.20499>, case 13: <D.20500>>
  <D.20490>:
  <D.20491>:
  <D.20492>:
  <D.20493>:
  if (esize < vsize) goto <D.31467>; else goto <D.31468>;
  <D.31467>:
  D.31469 = mono_get_exception_argument ("value", "not a widening conversion");
  mono_raise_exception (D.31469);
  <D.31468>:
  D.31470 = (short int) i64;
  MEM[(gint16 *)ea] = D.31470;
  return;
  <D.20494>:
  <D.20495>:
  <D.20496>:
  <D.20497>:
  <D.20498>:
  if (vsize >= esize) goto <D.31471>; else goto <D.31472>;
  <D.31471>:
  D.31473 = mono_get_exception_argument ("value", "not a widening conversion");
  mono_raise_exception (D.31473);
  <D.31472>:
  D.31474 = (short int) u64;
  MEM[(gint16 *)ea] = D.31474;
  return;
  <D.20499>:
  <D.20500>:
  D.31475 = mono_get_exception_argument ("value", "not a widening conversion");
  mono_raise_exception (D.31475);
  <D.31476>:
  <D.20501>:
  switch (vt) <default: <D.31486>, case 3: <D.20510>, case 4: <D.20502>, case 5: <D.20506>, case 6: <D.20503>, case 7: <D.20507>, case 8: <D.20504>, case 9: <D.20508>, case 10: <D.20505>, case 11: <D.20509>, case 12: <D.20511>, case 13: <D.20512>>
  <D.20502>:
  <D.20503>:
  <D.20504>:
  <D.20505>:
  if (esize < vsize) goto <D.31477>; else goto <D.31478>;
  <D.31477>:
  D.31479 = mono_get_exception_argument ("value", "not a widening conversion");
  mono_raise_exception (D.31479);
  <D.31478>:
  D.31480 = (int) i64;
  MEM[(gint32 *)ea] = D.31480;
  return;
  <D.20506>:
  <D.20507>:
  <D.20508>:
  <D.20509>:
  <D.20510>:
  if (vsize >= esize) goto <D.31481>; else goto <D.31482>;
  <D.31481>:
  D.31483 = mono_get_exception_argument ("value", "not a widening conversion");
  mono_raise_exception (D.31483);
  <D.31482>:
  D.31484 = (int) u64;
  MEM[(gint32 *)ea] = D.31484;
  return;
  <D.20511>:
  <D.20512>:
  D.31485 = mono_get_exception_argument ("value", "not a widening conversion");
  mono_raise_exception (D.31485);
  <D.31486>:
  <D.20513>:
  switch (vt) <default: <D.31495>, case 3: <D.20522>, case 4: <D.20514>, case 5: <D.20518>, case 6: <D.20515>, case 7: <D.20519>, case 8: <D.20516>, case 9: <D.20520>, case 10: <D.20517>, case 11: <D.20521>, case 12: <D.20523>, case 13: <D.20524>>
  <D.20514>:
  <D.20515>:
  <D.20516>:
  <D.20517>:
  if (esize < vsize) goto <D.31487>; else goto <D.31488>;
  <D.31487>:
  D.31489 = mono_get_exception_argument ("value", "not a widening conversion");
  mono_raise_exception (D.31489);
  <D.31488>:
  MEM[(gint64 *)ea] = i64;
  return;
  <D.20518>:
  <D.20519>:
  <D.20520>:
  <D.20521>:
  <D.20522>:
  if (vsize >= esize) goto <D.31490>; else goto <D.31491>;
  <D.31490>:
  D.31492 = mono_get_exception_argument ("value", "not a widening conversion");
  mono_raise_exception (D.31492);
  <D.31491>:
  u64.299 = (long long int) u64;
  MEM[(gint64 *)ea] = u64.299;
  return;
  <D.20523>:
  <D.20524>:
  D.31494 = mono_get_exception_argument ("value", "not a widening conversion");
  mono_raise_exception (D.31494);
  <D.31495>:
  <D.20525>:
  switch (vt) <default: <D.31502>, case 3: <D.20536>, case 4: <D.20528>, case 5: <D.20532>, case 6: <D.20529>, case 7: <D.20533>, case 8: <D.20530>, case 9: <D.20534>, case 10: <D.20531>, case 11: <D.20535>, case 12: <D.20526>, case 13: <D.20527>>
  <D.20526>:
  <D.20527>:
  if (esize < vsize) goto <D.31496>; else goto <D.31497>;
  <D.31496>:
  D.31498 = mono_get_exception_argument ("value", "not a widening conversion");
  mono_raise_exception (D.31498);
  <D.31497>:
  D.31499 = (float) r64;
  MEM[(gfloat *)ea] = D.31499;
  return;
  <D.20528>:
  <D.20529>:
  <D.20530>:
  <D.20531>:
  D.31500 = (float) i64;
  MEM[(gfloat *)ea] = D.31500;
  return;
  <D.20532>:
  <D.20533>:
  <D.20534>:
  <D.20535>:
  <D.20536>:
  D.31501 = (float) u64;
  MEM[(gfloat *)ea] = D.31501;
  return;
  <D.31502>:
  <D.20537>:
  switch (vt) <default: <D.31508>, case 3: <D.20548>, case 4: <D.20540>, case 5: <D.20544>, case 6: <D.20541>, case 7: <D.20545>, case 8: <D.20542>, case 9: <D.20546>, case 10: <D.20543>, case 11: <D.20547>, case 12: <D.20538>, case 13: <D.20539>>
  <D.20538>:
  <D.20539>:
  if (esize < vsize) goto <D.31503>; else goto <D.31504>;
  <D.31503>:
  D.31505 = mono_get_exception_argument ("value", "not a widening conversion");
  mono_raise_exception (D.31505);
  <D.31504>:
  MEM[(gdouble *)ea] = r64;
  return;
  <D.20540>:
  <D.20541>:
  <D.20542>:
  <D.20543>:
  D.31506 = (double) i64;
  MEM[(gdouble *)ea] = D.31506;
  return;
  <D.20544>:
  <D.20545>:
  <D.20546>:
  <D.20547>:
  <D.20548>:
  D.31507 = (double) u64;
  MEM[(gdouble *)ea] = D.31507;
  return;
  <D.31508>:
  <D.31509>:
  D.31510 = mono_get_runtime_callbacks ();
  D.31511 = D.31510->set_cast_details;
  D.31511 (vc, ec);
  D.31512 = mono_get_exception_invalid_cast ();
  mono_raise_exception (D.31512);
  return;
}


ves_icall_System_Array_SetValue (struct MonoArray * this, struct MonoObject * value, struct MonoArray * idxs)
{
  _Bool D.31516;
  long int D.31517;
  long int D.31518;
  struct MonoVTable * D.31523;
  struct MonoVTable * D.31524;
  unsigned char D.31525;
  _Bool D.31526;
  long int D.31527;
  long int D.31528;
  struct MonoArrayBounds * D.31533;
  unsigned int D.31535;
  unsigned char D.31536;
  unsigned int D.31537;
  struct MonoException * D.31538;
  struct MonoArrayBounds * D.31539;
  int D.31544;
  unsigned int D.31546;
  unsigned int D.31547;
  struct MonoException * D.31548;
  unsigned int D.31549;
  unsigned int i.300;
  unsigned int D.31553;
  gint32 * D.31554;
  int D.31555;
  unsigned int D.31556;
  struct MonoArrayBounds * D.31557;
  int D.31558;
  unsigned int D.31560;
  int D.31561;
  int D.31562;
  struct MonoException * D.31563;
  int D.31564;
  int D.31565;
  unsigned int pos.301;
  unsigned int D.31567;
  unsigned int D.31568;
  unsigned int D.31569;
  unsigned int D.31570;
  unsigned int D.31571;
  unsigned int pos.302;
  struct MonoClass * ac;
  struct MonoClass * ic;
  gint32 i;
  gint32 pos;
  gint32 * ind;

  D.31516 = idxs == 0B;
  D.31517 = (long int) D.31516;
  D.31518 = __builtin_expect (D.31517, 0);
  if (D.31518 != 0) goto <D.31519>; else goto <D.31520>;
  <D.31519>:
  {
    struct MonoException * ex;

    if (idxs != 0B) goto <D.31521>; else goto <D.31522>;
    <D.31521>:
    <D.31522>:
    ex = mono_get_exception_argument_null ("idxs");
    mono_raise_exception (ex);
  }
  <D.31520>:
  D.31523 = idxs->obj.vtable;
  ic = D.31523->klass;
  D.31524 = this->obj.vtable;
  ac = D.31524->klass;
  D.31525 = ic->rank;
  D.31526 = D.31525 != 1;
  D.31527 = (long int) D.31526;
  D.31528 = __builtin_expect (D.31527, 0);
  if (D.31528 != 0) goto <D.31529>; else goto <D.31530>;
  <D.31529>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "icall.c", 502, "ic->rank == 1");
  <D.31530>:
  D.31533 = idxs->bounds;
  if (D.31533 != 0B) goto <D.31531>; else goto <D.31534>;
  <D.31534>:
  D.31535 = idxs->max_length;
  D.31536 = ac->rank;
  D.31537 = (unsigned int) D.31536;
  if (D.31535 != D.31537) goto <D.31531>; else goto <D.31532>;
  <D.31531>:
  D.31538 = mono_get_exception_argument (0B, 0B);
  mono_raise_exception (D.31538);
  <D.31532>:
  ind = &idxs->vector;
  D.31539 = this->bounds;
  if (D.31539 == 0B) goto <D.31540>; else goto <D.31541>;
  <D.31540>:
  D.31544 = *ind;
  if (D.31544 < 0) goto <D.31542>; else goto <D.31545>;
  <D.31545>:
  D.31544 = *ind;
  D.31546 = (unsigned int) D.31544;
  D.31547 = this->max_length;
  if (D.31546 >= D.31547) goto <D.31542>; else goto <D.31543>;
  <D.31542>:
  D.31548 = mono_get_exception_index_out_of_range ();
  mono_raise_exception (D.31548);
  <D.31543>:
  D.31544 = *ind;
  D.31549 = (unsigned int) D.31544;
  ves_icall_System_Array_SetValueImpl (this, value, D.31549);
  return;
  <D.31541>:
  i = 0;
  goto <D.20561>;
  <D.20560>:
  i.300 = (unsigned int) i;
  D.31553 = i.300 * 4;
  D.31554 = ind + D.31553;
  D.31555 = *D.31554;
  D.31539 = this->bounds;
  i.300 = (unsigned int) i;
  D.31556 = i.300 * 8;
  D.31557 = D.31539 + D.31556;
  D.31558 = D.31557->lower_bound;
  if (D.31555 < D.31558) goto <D.31550>; else goto <D.31559>;
  <D.31559>:
  i.300 = (unsigned int) i;
  D.31553 = i.300 * 4;
  D.31554 = ind + D.31553;
  D.31555 = *D.31554;
  D.31539 = this->bounds;
  i.300 = (unsigned int) i;
  D.31556 = i.300 * 8;
  D.31557 = D.31539 + D.31556;
  D.31560 = D.31557->length;
  D.31561 = (int) D.31560;
  D.31539 = this->bounds;
  i.300 = (unsigned int) i;
  D.31556 = i.300 * 8;
  D.31557 = D.31539 + D.31556;
  D.31558 = D.31557->lower_bound;
  D.31562 = D.31561 + D.31558;
  if (D.31555 >= D.31562) goto <D.31550>; else goto <D.31551>;
  <D.31550>:
  D.31563 = mono_get_exception_index_out_of_range ();
  mono_raise_exception (D.31563);
  <D.31551>:
  i = i + 1;
  <D.20561>:
  D.31536 = ac->rank;
  D.31564 = (int) D.31536;
  if (D.31564 > i) goto <D.20560>; else goto <D.20562>;
  <D.20562>:
  D.31544 = *ind;
  D.31539 = this->bounds;
  D.31565 = D.31539->lower_bound;
  pos = D.31544 - D.31565;
  i = 1;
  goto <D.20564>;
  <D.20563>:
  D.31539 = this->bounds;
  i.300 = (unsigned int) i;
  D.31556 = i.300 * 8;
  D.31557 = D.31539 + D.31556;
  D.31560 = D.31557->length;
  pos.301 = (unsigned int) pos;
  D.31567 = D.31560 * pos.301;
  i.300 = (unsigned int) i;
  D.31553 = i.300 * 4;
  D.31554 = ind + D.31553;
  D.31555 = *D.31554;
  D.31568 = (unsigned int) D.31555;
  D.31569 = D.31567 + D.31568;
  D.31539 = this->bounds;
  i.300 = (unsigned int) i;
  D.31556 = i.300 * 8;
  D.31557 = D.31539 + D.31556;
  D.31558 = D.31557->lower_bound;
  D.31570 = (unsigned int) D.31558;
  D.31571 = D.31569 - D.31570;
  pos = (gint32) D.31571;
  i = i + 1;
  <D.20564>:
  D.31536 = ac->rank;
  D.31564 = (int) D.31536;
  if (D.31564 > i) goto <D.20563>; else goto <D.20565>;
  <D.20565>:
  pos.302 = (unsigned int) pos;
  ves_icall_System_Array_SetValueImpl (this, value, pos.302);
}


ves_icall_System_Array_SetGenericValueImpl (struct MonoObject * this, guint32 pos, void * value)
{
  struct MonoVTable * D.31574;
  double[0:] * D.31575;
  unsigned int esize.303;
  unsigned int D.31577;
  struct MonoType * D.31578;
  int D.31579;
  _Bool D.31582;
  long int D.31583;
  long int D.31584;
  void * D.31587;
  unsigned char D.31589;
  unsigned char D.31590;
  _Bool D.31591;
  long int D.31592;
  long int D.31593;
  int D.31596;
  _Bool D.31597;
  long int D.31598;
  long int D.31599;
  unsigned char D.31602;
  unsigned char D.31603;
  unsigned int esize.304;
  struct MonoClass * ac;
  struct MonoClass * ec;
  struct MonoArray * ao;
  gint32 esize;
  void * * ea;

  ao = this;
  D.31574 = ao->obj.vtable;
  ac = D.31574->klass;
  ec = ac->element_class;
  esize = mono_array_element_size (ac);
  D.31575 = &ao->vector;
  esize.303 = (unsigned int) esize;
  D.31577 = pos * esize.303;
  ea = D.31575 + D.31577;
  D.31578 = &ec->byval_arg;
  D.31579 = mono_type_is_reference (D.31578);
  if (D.31579 != 0) goto <D.31580>; else goto <D.31581>;
  <D.31580>:
  D.31582 = esize != 4;
  D.31583 = (long int) D.31582;
  D.31584 = __builtin_expect (D.31583, 0);
  if (D.31584 != 0) goto <D.31585>; else goto <D.31586>;
  <D.31585>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "icall.c", 793, "esize == sizeof (gpointer)");
  <D.31586>:
  D.31587 = MEM[(void * *)value];
  mono_gc_wbarrier_generic_store (ea, D.31587);
  goto <D.31588>;
  <D.31581>:
  D.31589 = BIT_FIELD_REF <*ec, 8, 160>;
  D.31590 = D.31589 & 1;
  D.31591 = D.31590 == 0;
  D.31592 = (long int) D.31591;
  D.31593 = __builtin_expect (D.31592, 0);
  if (D.31593 != 0) goto <D.31594>; else goto <D.31595>;
  <D.31594>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "icall.c", 796, "ec->inited");
  <D.31595>:
  D.31596 = mono_class_value_size (ec, 0B);
  D.31597 = D.31596 != esize;
  D.31598 = (long int) D.31597;
  D.31599 = __builtin_expect (D.31598, 0);
  if (D.31599 != 0) goto <D.31600>; else goto <D.31601>;
  <D.31600>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "icall.c", 797, "esize == mono_class_value_size (ec, NULL)");
  <D.31601>:
  D.31602 = BIT_FIELD_REF <*ec, 8, 184>;
  D.31603 = D.31602 & 8;
  if (D.31603 != 0) goto <D.31604>; else goto <D.31605>;
  <D.31604>:
  mono_gc_wbarrier_value_copy (ea, value, 1, ec);
  goto <D.31606>;
  <D.31605>:
  esize.304 = (unsigned int) esize;
  mono_gc_memmove_atomic (ea, value, esize.304);
  <D.31606>:
  <D.31588>:
}


ves_icall_System_Array_GetValueImpl (struct MonoObject * this, guint32 pos)
{
  struct MonoVTable * D.31608;
  double[0:] * D.31609;
  unsigned int esize.305;
  unsigned int D.31611;
  struct MonoClass * D.31612;
  unsigned char D.31613;
  unsigned char D.31614;
  struct MonoObject * D.31617;
  struct MonoVTable * D.31618;
  struct MonoDomain * D.31619;
  struct MonoClass * ac;
  struct MonoArray * ao;
  gint32 esize;
  void * * ea;

  ao = this;
  D.31608 = ao->obj.vtable;
  ac = D.31608->klass;
  esize = mono_array_element_size (ac);
  D.31609 = &ao->vector;
  esize.305 = (unsigned int) esize;
  D.31611 = pos * esize.305;
  ea = D.31609 + D.31611;
  D.31612 = ac->element_class;
  D.31613 = BIT_FIELD_REF <*D.31612, 8, 160>;
  D.31614 = D.31613 & 8;
  if (D.31614 != 0) goto <D.31615>; else goto <D.31616>;
  <D.31615>:
  D.31612 = ac->element_class;
  D.31618 = this->vtable;
  D.31619 = D.31618->domain;
  D.31617 = mono_value_box (D.31619, D.31612, ea);
  return D.31617;
  <D.31616>:
  D.31617 = *ea;
  return D.31617;
}


ves_icall_System_Array_GetValue (struct MonoObject * this, struct MonoObject * idxs)
{
  _Bool D.31621;
  long int D.31622;
  long int D.31623;
  struct MonoVTable * D.31628;
  struct MonoVTable * D.31629;
  unsigned char D.31630;
  _Bool D.31631;
  long int D.31632;
  long int D.31633;
  struct MonoArrayBounds * D.31638;
  unsigned int D.31640;
  unsigned char D.31641;
  unsigned int D.31642;
  struct MonoException * D.31643;
  struct MonoArrayBounds * D.31644;
  int D.31649;
  unsigned int D.31651;
  unsigned int D.31652;
  struct MonoException * D.31653;
  struct MonoObject * D.31654;
  unsigned int D.31655;
  unsigned int i.306;
  unsigned int D.31659;
  gint32 * D.31660;
  int D.31661;
  unsigned int D.31662;
  struct MonoArrayBounds * D.31663;
  int D.31664;
  unsigned int D.31666;
  int D.31667;
  int D.31668;
  struct MonoException * D.31669;
  int D.31670;
  int D.31671;
  unsigned int pos.307;
  unsigned int D.31673;
  unsigned int D.31674;
  unsigned int D.31675;
  unsigned int D.31676;
  unsigned int D.31677;
  unsigned int pos.308;
  struct MonoClass * ac;
  struct MonoClass * ic;
  struct MonoArray * ao;
  struct MonoArray * io;
  gint32 i;
  gint32 pos;
  gint32 * ind;

  D.31621 = idxs == 0B;
  D.31622 = (long int) D.31621;
  D.31623 = __builtin_expect (D.31622, 0);
  if (D.31623 != 0) goto <D.31624>; else goto <D.31625>;
  <D.31624>:
  {
    struct MonoException * ex;

    if (idxs != 0B) goto <D.31626>; else goto <D.31627>;
    <D.31626>:
    <D.31627>:
    ex = mono_get_exception_argument_null ("idxs");
    mono_raise_exception (ex);
  }
  <D.31625>:
  io = idxs;
  D.31628 = io->obj.vtable;
  ic = D.31628->klass;
  ao = this;
  D.31629 = ao->obj.vtable;
  ac = D.31629->klass;
  D.31630 = ic->rank;
  D.31631 = D.31630 != 1;
  D.31632 = (long int) D.31631;
  D.31633 = __builtin_expect (D.31632, 0);
  if (D.31633 != 0) goto <D.31634>; else goto <D.31635>;
  <D.31634>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "icall.c", 184, "ic->rank == 1");
  <D.31635>:
  D.31638 = io->bounds;
  if (D.31638 != 0B) goto <D.31636>; else goto <D.31639>;
  <D.31639>:
  D.31640 = io->max_length;
  D.31641 = ac->rank;
  D.31642 = (unsigned int) D.31641;
  if (D.31640 != D.31642) goto <D.31636>; else goto <D.31637>;
  <D.31636>:
  D.31643 = mono_get_exception_argument (0B, 0B);
  mono_raise_exception (D.31643);
  <D.31637>:
  ind = &io->vector;
  D.31644 = ao->bounds;
  if (D.31644 == 0B) goto <D.31645>; else goto <D.31646>;
  <D.31645>:
  D.31649 = *ind;
  if (D.31649 < 0) goto <D.31647>; else goto <D.31650>;
  <D.31650>:
  D.31649 = *ind;
  D.31651 = (unsigned int) D.31649;
  D.31652 = ao->max_length;
  if (D.31651 >= D.31652) goto <D.31647>; else goto <D.31648>;
  <D.31647>:
  D.31653 = mono_get_exception_index_out_of_range ();
  mono_raise_exception (D.31653);
  <D.31648>:
  D.31649 = *ind;
  D.31655 = (unsigned int) D.31649;
  D.31654 = ves_icall_System_Array_GetValueImpl (this, D.31655);
  return D.31654;
  <D.31646>:
  i = 0;
  goto <D.20350>;
  <D.20349>:
  i.306 = (unsigned int) i;
  D.31659 = i.306 * 4;
  D.31660 = ind + D.31659;
  D.31661 = *D.31660;
  D.31644 = ao->bounds;
  i.306 = (unsigned int) i;
  D.31662 = i.306 * 8;
  D.31663 = D.31644 + D.31662;
  D.31664 = D.31663->lower_bound;
  if (D.31661 < D.31664) goto <D.31656>; else goto <D.31665>;
  <D.31665>:
  i.306 = (unsigned int) i;
  D.31659 = i.306 * 4;
  D.31660 = ind + D.31659;
  D.31661 = *D.31660;
  D.31644 = ao->bounds;
  i.306 = (unsigned int) i;
  D.31662 = i.306 * 8;
  D.31663 = D.31644 + D.31662;
  D.31666 = D.31663->length;
  D.31667 = (int) D.31666;
  D.31644 = ao->bounds;
  i.306 = (unsigned int) i;
  D.31662 = i.306 * 8;
  D.31663 = D.31644 + D.31662;
  D.31664 = D.31663->lower_bound;
  D.31668 = D.31667 + D.31664;
  if (D.31661 >= D.31668) goto <D.31656>; else goto <D.31657>;
  <D.31656>:
  D.31669 = mono_get_exception_index_out_of_range ();
  mono_raise_exception (D.31669);
  <D.31657>:
  i = i + 1;
  <D.20350>:
  D.31641 = ac->rank;
  D.31670 = (int) D.31641;
  if (D.31670 > i) goto <D.20349>; else goto <D.20351>;
  <D.20351>:
  D.31649 = *ind;
  D.31644 = ao->bounds;
  D.31671 = D.31644->lower_bound;
  pos = D.31649 - D.31671;
  i = 1;
  goto <D.20353>;
  <D.20352>:
  D.31644 = ao->bounds;
  i.306 = (unsigned int) i;
  D.31662 = i.306 * 8;
  D.31663 = D.31644 + D.31662;
  D.31666 = D.31663->length;
  pos.307 = (unsigned int) pos;
  D.31673 = D.31666 * pos.307;
  i.306 = (unsigned int) i;
  D.31659 = i.306 * 4;
  D.31660 = ind + D.31659;
  D.31661 = *D.31660;
  D.31674 = (unsigned int) D.31661;
  D.31675 = D.31673 + D.31674;
  D.31644 = ao->bounds;
  i.306 = (unsigned int) i;
  D.31662 = i.306 * 8;
  D.31663 = D.31644 + D.31662;
  D.31664 = D.31663->lower_bound;
  D.31676 = (unsigned int) D.31664;
  D.31677 = D.31675 - D.31676;
  pos = (gint32) D.31677;
  i = i + 1;
  <D.20353>:
  D.31641 = ac->rank;
  D.31670 = (int) D.31641;
  if (D.31670 > i) goto <D.20352>; else goto <D.20354>;
  <D.20354>:
  pos.308 = (unsigned int) pos;
  D.31654 = ves_icall_System_Array_GetValueImpl (this, pos.308);
  return D.31654;
}


ves_icall_System_Array_GetRank (struct MonoObject * this)
{
  gint32 D.31680;
  struct MonoVTable * D.31681;
  struct MonoClass * D.31682;
  unsigned char D.31683;

  D.31681 = this->vtable;
  D.31682 = D.31681->klass;
  D.31683 = D.31682->rank;
  D.31680 = (gint32) D.31683;
  return D.31680;
}


ves_icall_System_Array_GetLowerBound (struct MonoArray * this, gint32 dimension)
{
  struct MonoVTable * D.31685;
  struct MonoClass * D.31686;
  unsigned char D.31687;
  _Bool D.31688;
  _Bool D.31689;
  _Bool D.31690;
  struct MonoException * D.31693;
  struct MonoArrayBounds * D.31694;
  gint32 D.31697;
  unsigned int dimension.309;
  unsigned int D.31699;
  struct MonoArrayBounds * D.31700;
  gint32 rank;

  D.31685 = MEM[(struct MonoObject *)this].vtable;
  D.31686 = D.31685->klass;
  D.31687 = D.31686->rank;
  rank = (gint32) D.31687;
  D.31688 = dimension < 0;
  D.31689 = dimension >= rank;
  D.31690 = D.31688 | D.31689;
  if (D.31690 != 0) goto <D.31691>; else goto <D.31692>;
  <D.31691>:
  D.31693 = mono_get_exception_index_out_of_range ();
  mono_raise_exception (D.31693);
  <D.31692>:
  D.31694 = this->bounds;
  if (D.31694 == 0B) goto <D.31695>; else goto <D.31696>;
  <D.31695>:
  D.31697 = 0;
  return D.31697;
  <D.31696>:
  D.31694 = this->bounds;
  dimension.309 = (unsigned int) dimension;
  D.31699 = dimension.309 * 8;
  D.31700 = D.31694 + D.31699;
  D.31697 = D.31700->lower_bound;
  return D.31697;
}


ves_icall_System_Array_GetLongLength (struct MonoArray * this, gint32 dimension)
{
  struct MonoVTable * D.31702;
  struct MonoClass * D.31703;
  unsigned char D.31704;
  _Bool D.31705;
  _Bool D.31706;
  _Bool D.31707;
  struct MonoException * D.31710;
  struct MonoArrayBounds * D.31711;
  gint64 D.31714;
  unsigned int D.31715;
  unsigned int dimension.310;
  unsigned int D.31717;
  struct MonoArrayBounds * D.31718;
  unsigned int D.31719;
  gint32 rank;

  D.31702 = MEM[(struct MonoObject *)this].vtable;
  D.31703 = D.31702->klass;
  D.31704 = D.31703->rank;
  rank = (gint32) D.31704;
  D.31705 = dimension < 0;
  D.31706 = dimension >= rank;
  D.31707 = D.31705 | D.31706;
  if (D.31707 != 0) goto <D.31708>; else goto <D.31709>;
  <D.31708>:
  D.31710 = mono_get_exception_index_out_of_range ();
  mono_raise_exception (D.31710);
  <D.31709>:
  D.31711 = this->bounds;
  if (D.31711 == 0B) goto <D.31712>; else goto <D.31713>;
  <D.31712>:
  D.31715 = this->max_length;
  D.31714 = (gint64) D.31715;
  return D.31714;
  <D.31713>:
  D.31711 = this->bounds;
  dimension.310 = (unsigned int) dimension;
  D.31717 = dimension.310 * 8;
  D.31718 = D.31711 + D.31717;
  D.31719 = D.31718->length;
  D.31714 = (gint64) D.31719;
  return D.31714;
}


ves_icall_System_Array_GetLength (struct MonoArray * this, gint32 dimension)
{
  struct MonoVTable * D.31721;
  struct MonoClass * D.31722;
  unsigned char D.31723;
  _Bool D.31724;
  _Bool D.31725;
  _Bool D.31726;
  struct MonoException * D.31729;
  struct MonoArrayBounds * D.31730;
  unsigned int dimension.311;
  unsigned int D.31735;
  struct MonoArrayBounds * D.31736;
  gint32 D.31737;
  gint32 rank;
  uintptr_t length;

  D.31721 = MEM[(struct MonoObject *)this].vtable;
  D.31722 = D.31721->klass;
  D.31723 = D.31722->rank;
  rank = (gint32) D.31723;
  D.31724 = dimension < 0;
  D.31725 = dimension >= rank;
  D.31726 = D.31724 | D.31725;
  if (D.31726 != 0) goto <D.31727>; else goto <D.31728>;
  <D.31727>:
  D.31729 = mono_get_exception_index_out_of_range ();
  mono_raise_exception (D.31729);
  <D.31728>:
  D.31730 = this->bounds;
  if (D.31730 == 0B) goto <D.31731>; else goto <D.31732>;
  <D.31731>:
  length = this->max_length;
  goto <D.31733>;
  <D.31732>:
  D.31730 = this->bounds;
  dimension.311 = (unsigned int) dimension;
  D.31735 = dimension.311 * 8;
  D.31736 = D.31730 + D.31735;
  length = D.31736->length;
  <D.31733>:
  D.31737 = (gint32) length;
  return D.31737;
}


ves_icall_System_Array_GetGenericValueImpl (struct MonoObject * this, guint32 pos, void * value)
{
  struct MonoVTable * D.31739;
  double[0:] * D.31740;
  unsigned int esize.312;
  unsigned int D.31742;
  unsigned int esize.313;
  struct MonoClass * ac;
  struct MonoArray * ao;
  gint32 esize;
  void * * ea;

  ao = this;
  D.31739 = ao->obj.vtable;
  ac = D.31739->klass;
  esize = mono_array_element_size (ac);
  D.31740 = &ao->vector;
  esize.312 = (unsigned int) esize;
  D.31742 = pos * esize.312;
  ea = D.31740 + D.31742;
  esize.313 = (unsigned int) esize;
  mono_gc_memmove_atomic (value, ea, esize.313);
}


ves_icall_System_Array_FastCopy (struct MonoArray * source, int source_idx, struct MonoArray * dest, int dest_idx, int length)
{
  unsigned char D.31744;
  unsigned char D.31745;
  gboolean D.31748;
  struct MonoArrayBounds * D.31751;
  struct MonoArrayBounds * D.31753;
  int D.31756;
  unsigned int D.31757;
  unsigned int D.31758;
  int D.31760;
  unsigned int D.31761;
  unsigned int D.31762;
  struct MonoClass * D.31763;
  struct MonoClass * D.31764;
  struct MonoClass * D.31765;
  unsigned char D.31768;
  unsigned char D.31769;
  unsigned char D.31776;
  unsigned char D.31778;
  unsigned char D.31779;
  int D.31780;
  struct MonoVTable * D.31785;
  struct MonoClass * D.31786;
  double[0:] * D.31787;
  int D.31788;
  sizetype D.31789;
  unsigned char D.31790;
  unsigned char D.31791;
  double[0:] * D.31795;
  int D.31796;
  sizetype D.31797;
  int D.31798;
  unsigned int D.31799;
  unsigned int dest_idx.314;
  unsigned int D.31802;
  unsigned int source_idx.315;
  unsigned int D.31804;
  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.31744 = src_vtable->rank;
  D.31745 = dest_vtable->rank;
  if (D.31744 != D.31745) goto <D.31746>; else goto <D.31747>;
  <D.31746>:
  D.31748 = 0;
  return D.31748;
  <D.31747>:
  D.31751 = source->bounds;
  if (D.31751 != 0B) goto <D.31749>; else goto <D.31752>;
  <D.31752>:
  D.31753 = dest->bounds;
  if (D.31753 != 0B) goto <D.31749>; else goto <D.31750>;
  <D.31749>:
  D.31748 = 0;
  return D.31748;
  <D.31750>:
  D.31756 = dest_idx + length;
  D.31757 = (unsigned int) D.31756;
  D.31758 = dest->max_length;
  if (D.31757 > D.31758) goto <D.31754>; else goto <D.31759>;
  <D.31759>:
  D.31760 = source_idx + length;
  D.31761 = (unsigned int) D.31760;
  D.31762 = source->max_length;
  if (D.31761 > D.31762) goto <D.31754>; else goto <D.31755>;
  <D.31754>:
  D.31748 = 0;
  return D.31748;
  <D.31755>:
  D.31763 = src_vtable->klass;
  src_class = D.31763->element_class;
  D.31764 = dest_vtable->klass;
  dest_class = D.31764->element_class;
  D.31765 = mono_defaults.object_class;
  if (D.31765 == src_class) goto <D.31766>; else goto <D.31767>;
  <D.31766>:
  D.31768 = BIT_FIELD_REF <*dest_class, 8, 160>;
  D.31769 = D.31768 & 8;
  if (D.31769 != 0) goto <D.31770>; else goto <D.31771>;
  <D.31770>:
  D.31748 = 0;
  return D.31748;
  <D.31771>:
  <D.31767>:
  if (src_class != dest_class) goto <D.31772>; else goto <D.31773>;
  <D.31772>:
  D.31768 = BIT_FIELD_REF <*dest_class, 8, 160>;
  D.31776 = D.31768 & 24;
  if (D.31776 != 0) goto <D.31774>; else goto <D.31777>;
  <D.31777>:
  D.31778 = BIT_FIELD_REF <*src_class, 8, 160>;
  D.31779 = D.31778 & 24;
  if (D.31779 != 0) goto <D.31774>; else goto <D.31775>;
  <D.31774>:
  D.31748 = 0;
  return D.31748;
  <D.31775>:
  D.31780 = mono_class_is_subclass_of (src_class, dest_class, 0);
  if (D.31780 == 0) goto <D.31781>; else goto <D.31782>;
  <D.31781>:
  D.31748 = 0;
  return D.31748;
  <D.31782>:
  <D.31773>:
  D.31768 = BIT_FIELD_REF <*dest_class, 8, 160>;
  D.31769 = D.31768 & 8;
  if (D.31769 != 0) goto <D.31783>; else goto <D.31784>;
  <D.31783>:
  D.31785 = source->obj.vtable;
  D.31786 = D.31785->klass;
  element_size = mono_array_element_size (D.31786);
  D.31787 = &source->vector;
  D.31788 = element_size * source_idx;
  D.31789 = (sizetype) D.31788;
  source_addr = D.31787 + D.31789;
  D.31790 = BIT_FIELD_REF <*dest_class, 8, 184>;
  D.31791 = D.31790 & 8;
  if (D.31791 != 0) goto <D.31792>; else goto <D.31793>;
  <D.31792>:
  mono_value_copy_array (dest, dest_idx, source_addr, length);
  goto <D.31794>;
  <D.31793>:
  D.31795 = &dest->vector;
  D.31796 = element_size * dest_idx;
  D.31797 = (sizetype) D.31796;
  dest_addr = D.31795 + D.31797;
  D.31798 = element_size * length;
  D.31799 = (unsigned int) D.31798;
  mono_gc_memmove_atomic (dest_addr, source_addr, D.31799);
  <D.31794>:
  goto <D.31800>;
  <D.31784>:
  {
    void * * __p;
    void * * __s;

    D.31795 = &dest->vector;
    dest_idx.314 = (unsigned int) dest_idx;
    D.31802 = dest_idx.314 * 4;
    __p = D.31795 + D.31802;
    D.31787 = &source->vector;
    source_idx.315 = (unsigned int) source_idx;
    D.31804 = source_idx.315 * 4;
    __s = D.31787 + D.31804;
    mono_gc_wbarrier_arrayref_copy (__p, __s, length);
  }
  <D.31800>:
  D.31748 = 1;
  return D.31748;
}


ves_icall_System_Array_CreateInstanceImpl64 (struct MonoReflectionType * type, struct MonoArray * lengths, struct MonoArray * bounds)
{
  _Bool D.31806;
  long int D.31807;
  long int D.31808;
  _Bool D.31813;
  long int D.31814;
  long int D.31815;
  unsigned int D.31820;
  _Bool D.31821;
  long int D.31822;
  long int D.31823;
  unsigned int D.31830;
  unsigned int D.31831;
  _Bool D.31832;
  long int D.31833;
  long int D.31834;
  char * D.31841;
  long long int D.31842;
  char * D.31844;
  long long int D.31845;
  struct MonoException * D.31846;
  unsigned int D.31847;
  struct MonoType * D.31848;
  unsigned int D.31852;
  char * D.31854;
  long long int D.31855;
  unsigned int D.31857;
  unsigned char D.31858;
  unsigned int D.31859;
  unsigned int D.31860;
  unsigned int D.31861;
  uintptr_t * D.31862;
  char * D.31863;
  long long unsigned int D.31864;
  unsigned int D.31865;
  unsigned int D.31868;
  unsigned int D.31869;
  unsigned int D.31870;
  uintptr_t * D.31871;
  char * D.31872;
  long long unsigned int D.31873;
  unsigned int D.31874;
  unsigned int D.31876;
  intptr_t * D.31877;
  struct MonoVTable * D.31878;
  struct MonoDomain * D.31879;
  struct MonoArray * D.31880;
  struct MonoClass * aklass;
  struct MonoClass * klass;
  struct MonoArray * array;
  uintptr_t * sizes;
  uintptr_t i;
  gboolean bounded;

  bounded = 0;
  D.31806 = type == 0B;
  D.31807 = (long int) D.31806;
  D.31808 = __builtin_expect (D.31807, 0);
  if (D.31808 != 0) goto <D.31809>; else goto <D.31810>;
  <D.31809>:
  {
    struct MonoException * ex;

    if (type != 0B) goto <D.31811>; else goto <D.31812>;
    <D.31811>:
    <D.31812>:
    ex = mono_get_exception_argument_null ("type");
    mono_raise_exception (ex);
  }
  <D.31810>:
  D.31813 = lengths == 0B;
  D.31814 = (long int) D.31813;
  D.31815 = __builtin_expect (D.31814, 0);
  if (D.31815 != 0) goto <D.31816>; else goto <D.31817>;
  <D.31816>:
  {
    struct MonoException * ex;

    if (lengths != 0B) goto <D.31818>; else goto <D.31819>;
    <D.31818>:
    <D.31819>:
    ex = mono_get_exception_argument_null ("lengths");
    mono_raise_exception (ex);
  }
  <D.31817>:
  D.31820 = mono_array_length (lengths);
  D.31821 = D.31820 == 0;
  D.31822 = (long int) D.31821;
  D.31823 = __builtin_expect (D.31822, 0);
  if (D.31823 != 0) goto <D.31824>; else goto <D.31825>;
  <D.31824>:
  {
    struct MonoException * ex;
    char * msg;

    msg = monoeg_g_strdup_printf ("assertion `%s\' failed", "mono_array_length (lengths) > 0");
    if (lengths != 0B) goto <D.31826>; else goto <D.31827>;
    <D.31826>:
    <D.31827>:
    ex = mono_get_exception_argument ("lengths", msg);
    monoeg_g_free (msg);
    mono_raise_exception (ex);
  }
  <D.31825>:
  if (bounds != 0B) goto <D.31828>; else goto <D.31829>;
  <D.31828>:
  D.31830 = mono_array_length (lengths);
  D.31831 = mono_array_length (bounds);
  D.31832 = D.31830 != D.31831;
  D.31833 = (long int) D.31832;
  D.31834 = __builtin_expect (D.31833, 0);
  if (D.31834 != 0) goto <D.31835>; else goto <D.31836>;
  <D.31835>:
  {
    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.31837>; else goto <D.31838>;
    <D.31837>:
    <D.31838>:
    ex = mono_get_exception_argument ("bounds", msg);
    monoeg_g_free (msg);
    mono_raise_exception (ex);
  }
  <D.31836>:
  <D.31829>:
  i = 0;
  goto <D.20607>;
  <D.20606>:
  D.31841 = mono_array_addr_with_size (lengths, 8, i);
  D.31842 = MEM[(gint64 *)D.31841];
  if (D.31842 < 0) goto <D.31839>; else goto <D.31843>;
  <D.31843>:
  D.31844 = mono_array_addr_with_size (lengths, 8, i);
  D.31845 = MEM[(gint64 *)D.31844];
  if (D.31845 > 2147483647) goto <D.31839>; else goto <D.31840>;
  <D.31839>:
  D.31846 = mono_get_exception_argument_out_of_range (0B);
  mono_raise_exception (D.31846);
  <D.31840>:
  i = i + 1;
  <D.20607>:
  D.31847 = mono_array_length (lengths);
  if (D.31847 > i) goto <D.20606>; else goto <D.20608>;
  <D.20608>:
  D.31848 = type->type;
  klass = mono_class_from_mono_type (D.31848);
  mono_class_init_or_throw (klass);
  if (bounds != 0B) goto <D.31851>; else goto <D.31849>;
  <D.31851>:
  D.31852 = mono_array_length (bounds);
  if (D.31852 == 1) goto <D.31853>; else goto <D.31849>;
  <D.31853>:
  D.31854 = mono_array_addr_with_size (bounds, 8, 0);
  D.31855 = MEM[(gint64 *)D.31854];
  if (D.31855 != 0) goto <D.31856>; else goto <D.31849>;
  <D.31856>:
  bounded = 1;
  goto <D.31850>;
  <D.31849>:
  bounded = 0;
  <D.31850>:
  D.31857 = mono_array_length (lengths);
  aklass = mono_bounded_array_class_get (klass, D.31857, bounded);
  D.31858 = aklass->rank;
  D.31859 = (unsigned int) D.31858;
  D.31860 = D.31859 * 8;
  sizes = __builtin_alloca (D.31860);
  i = 0;
  goto <D.20610>;
  <D.20609>:
  D.31861 = i * 4;
  D.31862 = sizes + D.31861;
  D.31863 = mono_array_addr_with_size (lengths, 8, i);
  D.31864 = MEM[(guint64 *)D.31863];
  D.31865 = (unsigned int) D.31864;
  *D.31862 = D.31865;
  if (bounds != 0B) goto <D.31866>; else goto <D.31867>;
  <D.31866>:
  D.31858 = aklass->rank;
  D.31868 = (unsigned int) D.31858;
  D.31869 = D.31868 + i;
  D.31870 = D.31869 * 4;
  D.31871 = sizes + D.31870;
  D.31872 = mono_array_addr_with_size (bounds, 8, i);
  D.31873 = MEM[(guint64 *)D.31872];
  D.31874 = (unsigned int) D.31873;
  *D.31871 = D.31874;
  goto <D.31875>;
  <D.31867>:
  D.31858 = aklass->rank;
  D.31868 = (unsigned int) D.31858;
  D.31869 = D.31868 + i;
  D.31870 = D.31869 * 4;
  D.31871 = sizes + D.31870;
  *D.31871 = 0;
  <D.31875>:
  i = i + 1;
  <D.20610>:
  D.31858 = aklass->rank;
  D.31868 = (unsigned int) D.31858;
  if (D.31868 > i) goto <D.20609>; else goto <D.20611>;
  <D.20611>:
  D.31858 = aklass->rank;
  D.31859 = (unsigned int) D.31858;
  D.31876 = D.31859 * 4;
  D.31877 = sizes + D.31876;
  D.31878 = MEM[(struct MonoObject *)type].vtable;
  D.31879 = D.31878->domain;
  array = mono_array_new_full (D.31879, aklass, sizes, D.31877);
  D.31880 = array;
  return D.31880;
}


ves_icall_System_Array_CreateInstanceImpl (struct MonoReflectionType * type, struct MonoArray * lengths, struct MonoArray * bounds)
{
  _Bool D.31882;
  long int D.31883;
  long int D.31884;
  _Bool D.31889;
  long int D.31890;
  long int D.31891;
  unsigned int D.31896;
  _Bool D.31897;
  long int D.31898;
  long int D.31899;
  unsigned int D.31906;
  unsigned int D.31907;
  _Bool D.31908;
  long int D.31909;
  long int D.31910;
  char * D.31915;
  int D.31916;
  struct MonoException * D.31919;
  unsigned int D.31920;
  struct MonoType * D.31921;
  unsigned int D.31925;
  char * D.31927;
  int D.31928;
  unsigned int D.31930;
  unsigned char D.31931;
  unsigned int D.31932;
  unsigned int D.31933;
  unsigned int D.31934;
  uintptr_t * D.31935;
  char * D.31936;
  unsigned int D.31937;
  unsigned int D.31940;
  unsigned int D.31941;
  unsigned int D.31942;
  uintptr_t * D.31943;
  char * D.31944;
  int D.31945;
  unsigned int D.31946;
  unsigned int D.31948;
  intptr_t * D.31949;
  struct MonoVTable * D.31950;
  struct MonoDomain * D.31951;
  struct MonoArray * D.31952;
  struct MonoClass * aklass;
  struct MonoClass * klass;
  struct MonoArray * array;
  uintptr_t * sizes;
  uintptr_t i;
  gboolean bounded;

  bounded = 0;
  D.31882 = type == 0B;
  D.31883 = (long int) D.31882;
  D.31884 = __builtin_expect (D.31883, 0);
  if (D.31884 != 0) goto <D.31885>; else goto <D.31886>;
  <D.31885>:
  {
    struct MonoException * ex;

    if (type != 0B) goto <D.31887>; else goto <D.31888>;
    <D.31887>:
    <D.31888>:
    ex = mono_get_exception_argument_null ("type");
    mono_raise_exception (ex);
  }
  <D.31886>:
  D.31889 = lengths == 0B;
  D.31890 = (long int) D.31889;
  D.31891 = __builtin_expect (D.31890, 0);
  if (D.31891 != 0) goto <D.31892>; else goto <D.31893>;
  <D.31892>:
  {
    struct MonoException * ex;

    if (lengths != 0B) goto <D.31894>; else goto <D.31895>;
    <D.31894>:
    <D.31895>:
    ex = mono_get_exception_argument_null ("lengths");
    mono_raise_exception (ex);
  }
  <D.31893>:
  D.31896 = mono_array_length (lengths);
  D.31897 = D.31896 == 0;
  D.31898 = (long int) D.31897;
  D.31899 = __builtin_expect (D.31898, 0);
  if (D.31899 != 0) goto <D.31900>; else goto <D.31901>;
  <D.31900>:
  {
    struct MonoException * ex;
    char * msg;

    msg = monoeg_g_strdup_printf ("assertion `%s\' failed", "mono_array_length (lengths) > 0");
    if (lengths != 0B) goto <D.31902>; else goto <D.31903>;
    <D.31902>:
    <D.31903>:
    ex = mono_get_exception_argument ("lengths", msg);
    monoeg_g_free (msg);
    mono_raise_exception (ex);
  }
  <D.31901>:
  if (bounds != 0B) goto <D.31904>; else goto <D.31905>;
  <D.31904>:
  D.31906 = mono_array_length (lengths);
  D.31907 = mono_array_length (bounds);
  D.31908 = D.31906 != D.31907;
  D.31909 = (long int) D.31908;
  D.31910 = __builtin_expect (D.31909, 0);
  if (D.31910 != 0) goto <D.31911>; else goto <D.31912>;
  <D.31911>:
  {
    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.31913>; else goto <D.31914>;
    <D.31913>:
    <D.31914>:
    ex = mono_get_exception_argument ("bounds", msg);
    monoeg_g_free (msg);
    mono_raise_exception (ex);
  }
  <D.31912>:
  <D.31905>:
  i = 0;
  goto <D.20584>;
  <D.20583>:
  D.31915 = mono_array_addr_with_size (lengths, 4, i);
  D.31916 = MEM[(gint32 *)D.31915];
  if (D.31916 < 0) goto <D.31917>; else goto <D.31918>;
  <D.31917>:
  D.31919 = mono_get_exception_argument_out_of_range (0B);
  mono_raise_exception (D.31919);
  <D.31918>:
  i = i + 1;
  <D.20584>:
  D.31920 = mono_array_length (lengths);
  if (D.31920 > i) goto <D.20583>; else goto <D.20585>;
  <D.20585>:
  D.31921 = type->type;
  klass = mono_class_from_mono_type (D.31921);
  mono_class_init_or_throw (klass);
  if (bounds != 0B) goto <D.31924>; else goto <D.31922>;
  <D.31924>:
  D.31925 = mono_array_length (bounds);
  if (D.31925 == 1) goto <D.31926>; else goto <D.31922>;
  <D.31926>:
  D.31927 = mono_array_addr_with_size (bounds, 4, 0);
  D.31928 = MEM[(gint32 *)D.31927];
  if (D.31928 != 0) goto <D.31929>; else goto <D.31922>;
  <D.31929>:
  bounded = 1;
  goto <D.31923>;
  <D.31922>:
  bounded = 0;
  <D.31923>:
  D.31930 = mono_array_length (lengths);
  aklass = mono_bounded_array_class_get (klass, D.31930, bounded);
  D.31931 = aklass->rank;
  D.31932 = (unsigned int) D.31931;
  D.31933 = D.31932 * 8;
  sizes = __builtin_alloca (D.31933);
  i = 0;
  goto <D.20587>;
  <D.20586>:
  D.31934 = i * 4;
  D.31935 = sizes + D.31934;
  D.31936 = mono_array_addr_with_size (lengths, 4, i);
  D.31937 = MEM[(guint32 *)D.31936];
  *D.31935 = D.31937;
  if (bounds != 0B) goto <D.31938>; else goto <D.31939>;
  <D.31938>:
  D.31931 = aklass->rank;
  D.31940 = (unsigned int) D.31931;
  D.31941 = D.31940 + i;
  D.31942 = D.31941 * 4;
  D.31943 = sizes + D.31942;
  D.31944 = mono_array_addr_with_size (bounds, 4, i);
  D.31945 = MEM[(gint32 *)D.31944];
  D.31946 = (unsigned int) D.31945;
  *D.31943 = D.31946;
  goto <D.31947>;
  <D.31939>:
  D.31931 = aklass->rank;
  D.31940 = (unsigned int) D.31931;
  D.31941 = D.31940 + i;
  D.31942 = D.31941 * 4;
  D.31943 = sizes + D.31942;
  *D.31943 = 0;
  <D.31947>:
  i = i + 1;
  <D.20587>:
  D.31931 = aklass->rank;
  D.31940 = (unsigned int) D.31931;
  if (D.31940 > i) goto <D.20586>; else goto <D.20588>;
  <D.20588>:
  D.31931 = aklass->rank;
  D.31932 = (unsigned int) D.31931;
  D.31948 = D.31932 * 4;
  D.31949 = sizes + D.31948;
  D.31950 = MEM[(struct MonoObject *)type].vtable;
  D.31951 = D.31950->domain;
  array = mono_array_new_full (D.31951, aklass, sizes, D.31949);
  D.31952 = array;
  return D.31952;
}


ves_icall_System_Array_ClearInternal (struct MonoArray * arr, int idx, int length)
{
  struct MonoVTable * D.31954;
  struct MonoClass * D.31955;
  int D.31956;
  unsigned int D.31957;
  double[0:] * D.31958;
  int D.31959;
  sizetype D.31960;
  void * D.31961;
  int sz;

  D.31954 = MEM[(struct MonoObject *)arr].vtable;
  D.31955 = D.31954->klass;
  sz = mono_array_element_size (D.31955);
  D.31956 = length * sz;
  D.31957 = (unsigned int) D.31956;
  D.31958 = &arr->vector;
  D.31959 = sz * idx;
  D.31960 = (sizetype) D.31959;
  D.31961 = D.31958 + D.31960;
  mono_gc_bzero_atomic (D.31961, D.31957);
}


mono_ArgIterator_Setup (struct MonoArgIterator * iter, char * argsp, char * start)
{
  struct MonoMethodSignature * D.31962;
  struct MonoMethodSignature * D.31963;
  short int D.31964;
  int D.31965;
  short unsigned int D.31966;
  int D.31967;
  _Bool D.31968;
  long int D.31969;
  long int D.31970;
  unsigned char D.31973;
  unsigned char D.31974;
  _Bool D.31975;
  long int D.31976;
  long int D.31977;
  void * D.31983;
  int D.31984;

  D.31962 = MEM[(struct MonoMethodSignature * *)argsp];
  iter->sig = D.31962;
  D.31963 = iter->sig;
  D.31964 = D.31963->sentinelpos;
  D.31965 = (int) D.31964;
  D.31963 = iter->sig;
  D.31966 = D.31963->param_count;
  D.31967 = (int) D.31966;
  D.31968 = D.31965 > D.31967;
  D.31969 = (long int) D.31968;
  D.31970 = __builtin_expect (D.31969, 0);
  if (D.31970 != 0) goto <D.31971>; else goto <D.31972>;
  <D.31971>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "icall.c", 7168, "iter->sig->sentinelpos <= iter->sig->param_count");
  <D.31972>:
  D.31963 = iter->sig;
  D.31973 = BIT_FIELD_REF <*D.31963, 8, 80>;
  D.31974 = D.31973 & 63;
  D.31975 = D.31974 != 5;
  D.31976 = (long int) D.31975;
  D.31977 = __builtin_expect (D.31976, 0);
  if (D.31977 != 0) goto <D.31978>; else goto <D.31979>;
  <D.31978>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "icall.c", 7169, "iter->sig->call_convention == MONO_CALL_VARARG");
  <D.31979>:
  iter->next_arg = 0;
  if (start != 0B) goto <D.31980>; else goto <D.31981>;
  <D.31980>:
  iter->args = start;
  goto <D.31982>;
  <D.31981>:
  D.31983 = argsp + 4;
  iter->args = D.31983;
  <D.31982>:
  D.31963 = iter->sig;
  D.31966 = D.31963->param_count;
  D.31967 = (int) D.31966;
  D.31963 = iter->sig;
  D.31964 = D.31963->sentinelpos;
  D.31965 = (int) D.31964;
  D.31984 = D.31967 - D.31965;
  iter->num_args = D.31984;
}


mono_ArgIterator_IntGetNextArgType (struct MonoArgIterator * iter)
{
  struct MonoMethodSignature * D.31985;
  short int D.31986;
  int D.31987;
  int D.31988;
  short unsigned int D.31989;
  int D.31990;
  _Bool D.31991;
  long int D.31992;
  long int D.31993;
  struct MonoType * D.31996;
  gint i;

  D.31985 = iter->sig;
  D.31986 = D.31985->sentinelpos;
  D.31987 = (int) D.31986;
  D.31988 = iter->next_arg;
  i = D.31987 + D.31988;
  D.31985 = iter->sig;
  D.31989 = D.31985->param_count;
  D.31990 = (int) D.31989;
  D.31991 = D.31990 <= i;
  D.31992 = (long int) D.31991;
  D.31993 = __builtin_expect (D.31992, 0);
  if (D.31993 != 0) goto <D.31994>; else goto <D.31995>;
  <D.31994>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "icall.c", 7267, "i < iter->sig->param_count");
  <D.31995>:
  D.31985 = iter->sig;
  D.31996 = D.31985->params[i];
  return D.31996;
}


mono_ArgIterator_IntGetNextArgT (struct MonoArgIterator * iter, struct MonoType * type)
{
  struct MonoMethodSignature * D.31999;
  short int D.32000;
  int D.32001;
  int D.32002;
  int D.32003;
  short unsigned int D.32004;
  unsigned int D.32005;
  _Bool D.32006;
  long int D.32007;
  long int D.32008;
  struct MonoType * D.32011;
  int D.32012;
  struct MonoType * D.32015;
  struct MonoClass * D.32016;
  int D.32017;
  void * D.32018;
  void * D.32019;
  int D.32020;
  guint32 i;
  guint32 arg_size;
  gint32 align;
  struct MonoTypedRef res;

  try
    {
      D.31999 = iter->sig;
      D.32000 = D.31999->sentinelpos;
      D.32001 = (int) D.32000;
      D.32002 = iter->next_arg;
      D.32003 = D.32001 + D.32002;
      i = (guint32) D.32003;
      D.31999 = iter->sig;
      D.32004 = D.31999->param_count;
      D.32005 = (unsigned int) D.32004;
      D.32006 = D.32005 <= i;
      D.32007 = (long int) D.32006;
      D.32008 = __builtin_expect (D.32007, 0);
      if (D.32008 != 0) goto <D.32009>; else goto <D.32010>;
      <D.32009>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "icall.c", 7233, "i < iter->sig->param_count");
      <D.32010>:
      goto <D.23106>;
      <D.23107>:
      D.31999 = iter->sig;
      D.32011 = D.31999->params[i];
      D.32012 = mono_metadata_type_equal (type, D.32011);
      if (D.32012 == 0) goto <D.32013>; else goto <D.32014>;
      <D.32013>:
      // predicted unlikely by continue predictor.
      goto <D.23106>;
      <D.32014>:
      D.31999 = iter->sig;
      D.32011 = D.31999->params[i];
      res.type = D.32011;
      D.32015 = res.type;
      D.32016 = mono_class_from_mono_type (D.32015);
      res.klass = D.32016;
      D.32015 = res.type;
      D.32017 = mono_type_stack_size (D.32015, &align);
      arg_size = (guint32) D.32017;
      D.32018 = iter->args;
      res.value = D.32018;
      D.32018 = iter->args;
      D.32019 = D.32018 + arg_size;
      iter->args = D.32019;
      D.32002 = iter->next_arg;
      D.32020 = D.32002 + 1;
      iter->next_arg = D.32020;
      <retval> = res;
      return <retval>;
      <D.23106>:
      D.31999 = iter->sig;
      D.32004 = D.31999->param_count;
      D.32005 = (unsigned int) D.32004;
      if (D.32005 > i) goto <D.23107>; else goto <D.23108>;
      <D.23108>:
      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.32024;
  short int D.32025;
  int D.32026;
  int D.32027;
  int D.32028;
  short unsigned int D.32029;
  unsigned int D.32030;
  _Bool D.32031;
  long int D.32032;
  long int D.32033;
  struct MonoType * D.32036;
  struct MonoType * D.32037;
  struct MonoClass * D.32038;
  int D.32039;
  void * D.32040;
  void * D.32041;
  int D.32042;
  guint32 i;
  guint32 arg_size;
  gint32 align;
  struct MonoTypedRef res;

  try
    {
      D.32024 = iter->sig;
      D.32025 = D.32024->sentinelpos;
      D.32026 = (int) D.32025;
      D.32027 = iter->next_arg;
      D.32028 = D.32026 + D.32027;
      i = (guint32) D.32028;
      D.32024 = iter->sig;
      D.32029 = D.32024->param_count;
      D.32030 = (unsigned int) D.32029;
      D.32031 = D.32030 <= i;
      D.32032 = (long int) D.32031;
      D.32033 = __builtin_expect (D.32032, 0);
      if (D.32033 != 0) goto <D.32034>; else goto <D.32035>;
      <D.32034>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "icall.c", 7193, "i < iter->sig->param_count");
      <D.32035>:
      D.32024 = iter->sig;
      D.32036 = D.32024->params[i];
      res.type = D.32036;
      D.32037 = res.type;
      D.32038 = mono_class_from_mono_type (D.32037);
      res.klass = D.32038;
      D.32037 = res.type;
      D.32039 = mono_type_stack_size (D.32037, &align);
      arg_size = (guint32) D.32039;
      D.32040 = iter->args;
      res.value = D.32040;
      D.32040 = iter->args;
      D.32041 = D.32040 + arg_size;
      iter->args = D.32041;
      D.32027 = iter->next_arg;
      D.32042 = D.32027 + 1;
      iter->next_arg = D.32042;
      <retval> = res;
      return <retval>;
    }
  finally
    {
      align = {CLOBBER};
      res = {CLOBBER};
    }
}


ves_icall_System_Activator_CreateInstanceInternal (struct MonoReflectionType * type)
{
  struct MonoVTable * D.32045;
  struct MonoType * D.32046;
  int D.32047;
  struct MonoObject * D.32050;
  struct MonoClass * klass;
  struct MonoDomain * domain;

  D.32045 = MEM[(struct MonoObject *)type].vtable;
  domain = D.32045->domain;
  D.32046 = type->type;
  klass = mono_class_from_mono_type (D.32046);
  mono_class_init_or_throw (klass);
  D.32047 = mono_class_is_nullable (klass);
  if (D.32047 != 0) goto <D.32048>; else goto <D.32049>;
  <D.32048>:
  D.32050 = 0B;
  return D.32050;
  <D.32049>:
  D.32050 = mono_object_new (domain, klass);
  return D.32050;
}


ves_icall_Mono_Runtime_GetDisplayName ()
{
  struct MonoRuntimeCallbacks * D.32052;
  char * (*<T26ed>) (void) D.32053;
  struct MonoDomain * D.32054;
  struct MonoString * D.32055;
  char * info;
  struct MonoString * display_name;

  D.32052 = mono_get_runtime_callbacks ();
  D.32053 = D.32052->get_runtime_build_info;
  info = D.32053 ();
  D.32054 = mono_domain_get ();
  display_name = mono_string_new (D.32054, info);
  monoeg_g_free (info);
  D.32055 = display_name;
  return D.32055;
}


compare_method_imap (const void * key, const void * elem)
{
  short unsigned int D.32057;
  sizetype D.32058;
  int D.32059;
  int D.24965;
  const char * method_name;

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

    D.24965 = __builtin_strcmp (key, method_name);
  }
  D.32059 = D.24965;
  return D.32059;
}


mono_lookup_icall_symbol (struct MonoMethod * m)
{
  struct _IO_FILE * stderr.316;
  const char * D.32062;

  stderr.316 = stderr;
  fprintf (stderr.316, "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.32062 = 0B;
  return D.32062;
}


fprintf (struct FILE * restrict __stream, const char * restrict __fmt)
{
  int D.32064;

  D.32064 = __fprintf_chk (__stream, 1, __fmt, __builtin_va_arg_pack ());
  return D.32064;
}


mono_create_icall_signature (const char * sigstr)
{
  struct GHashTable * D.32066;
  struct MonoMethodSignature * D.32069;
  gchar * D.32070;
  int D.32071;
  unsigned int D.32072;
  gchar * D.32073;
  struct MonoType * D.32074;
  int D.32075;
  unsigned int i.317;
  unsigned int D.32077;
  gchar * * D.32078;
  gchar * D.32079;
  struct MonoType * D.32080;
  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.32066 = corlib->helper_signatures;
  res = monoeg_g_hash_table_lookup (D.32066, sigstr);
  mono_image_unlock (corlib);
  if (res != 0B) goto <D.32067>; else goto <D.32068>;
  <D.32067>:
  D.32069 = res;
  return D.32069;
  <D.32068>:
  parts = monoeg_g_strsplit (sigstr, " ", 256);
  tmp = parts;
  len = 0;
  goto <D.25189>;
  <D.25188>:
  len = len + 1;
  tmp = tmp + 4;
  <D.25189>:
  D.32070 = *tmp;
  if (D.32070 != 0B) goto <D.25188>; else goto <D.25190>;
  <D.25190>:
  D.32071 = len + -1;
  D.32072 = (unsigned int) D.32071;
  res = mono_metadata_signature_alloc (corlib, D.32072);
  res->pinvoke = 1;
  D.32073 = *parts;
  D.32074 = type_from_typename (D.32073);
  res->ret = D.32074;
  i = 1;
  goto <D.25192>;
  <D.25191>:
  D.32075 = i + -1;
  i.317 = (unsigned int) i;
  D.32077 = i.317 * 4;
  D.32078 = parts + D.32077;
  D.32079 = *D.32078;
  D.32080 = type_from_typename (D.32079);
  res->params[D.32075] = D.32080;
  i = i + 1;
  <D.25192>:
  if (i < len) goto <D.25191>; else goto <D.25193>;
  <D.25193>:
  monoeg_g_strfreev (parts);
  mono_image_lock (corlib);
  D.32066 = corlib->helper_signatures;
  res2 = monoeg_g_hash_table_lookup (D.32066, sigstr);
  if (res2 != 0B) goto <D.32081>; else goto <D.32082>;
  <D.32081>:
  res = res2;
  goto <D.32083>;
  <D.32082>:
  D.32066 = corlib->helper_signatures;
  monoeg_g_hash_table_insert_replace (D.32066, sigstr, res, 0);
  <D.32083>:
  mono_image_unlock (corlib);
  D.32069 = res;
  return D.32069;
}


type_from_typename (char * typename)
{
  int D.25023;
  int iftmp.318;
  int D.25022;
  const char[4] * D.32088;
  unsigned char D.32089;
  int D.32090;
  unsigned char D.32091;
  int D.32092;
  _Bool D.32093;
  _Bool D.32094;
  _Bool D.32095;
  const unsigned char * D.32098;
  unsigned char D.32099;
  int D.32100;
  const unsigned char * D.32101;
  unsigned char D.32102;
  int D.32103;
  _Bool D.32104;
  _Bool D.32105;
  const unsigned char * D.32108;
  unsigned char D.32109;
  int D.32110;
  const unsigned char * D.32111;
  unsigned char D.32112;
  int D.32113;
  _Bool D.32114;
  _Bool D.32115;
  const unsigned char * D.32118;
  unsigned char D.32119;
  int D.32120;
  const unsigned char * D.32121;
  unsigned char D.32122;
  int D.32123;
  int D.25032;
  int iftmp.319;
  int D.25031;
  const char[4] * D.32131;
  unsigned char D.32132;
  int D.32133;
  unsigned char D.32134;
  int D.32135;
  _Bool D.32136;
  _Bool D.32137;
  _Bool D.32138;
  const unsigned char * D.32141;
  unsigned char D.32142;
  int D.32143;
  const unsigned char * D.32144;
  unsigned char D.32145;
  int D.32146;
  _Bool D.32147;
  _Bool D.32148;
  const unsigned char * D.32151;
  unsigned char D.32152;
  int D.32153;
  const unsigned char * D.32154;
  unsigned char D.32155;
  int D.32156;
  _Bool D.32157;
  _Bool D.32158;
  const unsigned char * D.32161;
  unsigned char D.32162;
  int D.32163;
  const unsigned char * D.32164;
  unsigned char D.32165;
  int D.32166;
  int D.25041;
  int iftmp.320;
  int D.25040;
  const char[5] * D.32174;
  unsigned char D.32175;
  int D.32176;
  unsigned char D.32177;
  int D.32178;
  _Bool D.32179;
  _Bool D.32180;
  _Bool D.32181;
  const unsigned char * D.32184;
  unsigned char D.32185;
  int D.32186;
  const unsigned char * D.32187;
  unsigned char D.32188;
  int D.32189;
  _Bool D.32190;
  _Bool D.32191;
  const unsigned char * D.32194;
  unsigned char D.32195;
  int D.32196;
  const unsigned char * D.32197;
  unsigned char D.32198;
  int D.32199;
  _Bool D.32200;
  _Bool D.32201;
  const unsigned char * D.32204;
  unsigned char D.32205;
  int D.32206;
  const unsigned char * D.32207;
  unsigned char D.32208;
  int D.32209;
  int D.25050;
  int iftmp.321;
  int D.25049;
  const char[6] * D.32217;
  unsigned char D.32218;
  int D.32219;
  unsigned char D.32220;
  int D.32221;
  _Bool D.32222;
  _Bool D.32223;
  _Bool D.32224;
  const unsigned char * D.32227;
  unsigned char D.32228;
  int D.32229;
  const unsigned char * D.32230;
  unsigned char D.32231;
  int D.32232;
  _Bool D.32233;
  _Bool D.32234;
  const unsigned char * D.32237;
  unsigned char D.32238;
  int D.32239;
  const unsigned char * D.32240;
  unsigned char D.32241;
  int D.32242;
  _Bool D.32243;
  _Bool D.32244;
  const unsigned char * D.32247;
  unsigned char D.32248;
  int D.32249;
  const unsigned char * D.32250;
  unsigned char D.32251;
  int D.32252;
  int D.25059;
  int iftmp.322;
  int D.25058;
  const char[7] * D.32260;
  unsigned char D.32261;
  int D.32262;
  unsigned char D.32263;
  int D.32264;
  _Bool D.32265;
  _Bool D.32266;
  _Bool D.32267;
  const unsigned char * D.32270;
  unsigned char D.32271;
  int D.32272;
  const unsigned char * D.32273;
  unsigned char D.32274;
  int D.32275;
  _Bool D.32276;
  _Bool D.32277;
  const unsigned char * D.32280;
  unsigned char D.32281;
  int D.32282;
  const unsigned char * D.32283;
  unsigned char D.32284;
  int D.32285;
  _Bool D.32286;
  _Bool D.32287;
  const unsigned char * D.32290;
  unsigned char D.32291;
  int D.32292;
  const unsigned char * D.32293;
  unsigned char D.32294;
  int D.32295;
  int D.25068;
  int iftmp.323;
  int D.25067;
  const char[5] * D.32303;
  unsigned char D.32304;
  int D.32305;
  unsigned char D.32306;
  int D.32307;
  _Bool D.32308;
  _Bool D.32309;
  _Bool D.32310;
  const unsigned char * D.32313;
  unsigned char D.32314;
  int D.32315;
  const unsigned char * D.32316;
  unsigned char D.32317;
  int D.32318;
  _Bool D.32319;
  _Bool D.32320;
  const unsigned char * D.32323;
  unsigned char D.32324;
  int D.32325;
  const unsigned char * D.32326;
  unsigned char D.32327;
  int D.32328;
  _Bool D.32329;
  _Bool D.32330;
  const unsigned char * D.32333;
  unsigned char D.32334;
  int D.32335;
  const unsigned char * D.32336;
  unsigned char D.32337;
  int D.32338;
  int D.25077;
  int iftmp.324;
  int D.25076;
  const char[6] * D.32346;
  unsigned char D.32347;
  int D.32348;
  unsigned char D.32349;
  int D.32350;
  _Bool D.32351;
  _Bool D.32352;
  _Bool D.32353;
  const unsigned char * D.32356;
  unsigned char D.32357;
  int D.32358;
  const unsigned char * D.32359;
  unsigned char D.32360;
  int D.32361;
  _Bool D.32362;
  _Bool D.32363;
  const unsigned char * D.32366;
  unsigned char D.32367;
  int D.32368;
  const unsigned char * D.32369;
  unsigned char D.32370;
  int D.32371;
  _Bool D.32372;
  _Bool D.32373;
  const unsigned char * D.32376;
  unsigned char D.32377;
  int D.32378;
  const unsigned char * D.32379;
  unsigned char D.32380;
  int D.32381;
  int D.25086;
  int iftmp.325;
  int D.25085;
  const char[6] * D.32389;
  unsigned char D.32390;
  int D.32391;
  unsigned char D.32392;
  int D.32393;
  _Bool D.32394;
  _Bool D.32395;
  _Bool D.32396;
  const unsigned char * D.32399;
  unsigned char D.32400;
  int D.32401;
  const unsigned char * D.32402;
  unsigned char D.32403;
  int D.32404;
  _Bool D.32405;
  _Bool D.32406;
  const unsigned char * D.32409;
  unsigned char D.32410;
  int D.32411;
  const unsigned char * D.32412;
  unsigned char D.32413;
  int D.32414;
  _Bool D.32415;
  _Bool D.32416;
  const unsigned char * D.32419;
  unsigned char D.32420;
  int D.32421;
  const unsigned char * D.32422;
  unsigned char D.32423;
  int D.32424;
  int D.25095;
  int iftmp.326;
  int D.25094;
  const char[7] * D.32432;
  unsigned char D.32433;
  int D.32434;
  unsigned char D.32435;
  int D.32436;
  _Bool D.32437;
  _Bool D.32438;
  _Bool D.32439;
  const unsigned char * D.32442;
  unsigned char D.32443;
  int D.32444;
  const unsigned char * D.32445;
  unsigned char D.32446;
  int D.32447;
  _Bool D.32448;
  _Bool D.32449;
  const unsigned char * D.32452;
  unsigned char D.32453;
  int D.32454;
  const unsigned char * D.32455;
  unsigned char D.32456;
  int D.32457;
  _Bool D.32458;
  _Bool D.32459;
  const unsigned char * D.32462;
  unsigned char D.32463;
  int D.32464;
  const unsigned char * D.32465;
  unsigned char D.32466;
  int D.32467;
  int D.25104;
  int iftmp.327;
  int D.25103;
  const char[5] * D.32475;
  unsigned char D.32476;
  int D.32477;
  unsigned char D.32478;
  int D.32479;
  _Bool D.32480;
  _Bool D.32481;
  _Bool D.32482;
  const unsigned char * D.32485;
  unsigned char D.32486;
  int D.32487;
  const unsigned char * D.32488;
  unsigned char D.32489;
  int D.32490;
  _Bool D.32491;
  _Bool D.32492;
  const unsigned char * D.32495;
  unsigned char D.32496;
  int D.32497;
  const unsigned char * D.32498;
  unsigned char D.32499;
  int D.32500;
  _Bool D.32501;
  _Bool D.32502;
  const unsigned char * D.32505;
  unsigned char D.32506;
  int D.32507;
  const unsigned char * D.32508;
  unsigned char D.32509;
  int D.32510;
  int D.25113;
  int iftmp.328;
  int D.25112;
  const char[6] * D.32518;
  unsigned char D.32519;
  int D.32520;
  unsigned char D.32521;
  int D.32522;
  _Bool D.32523;
  _Bool D.32524;
  _Bool D.32525;
  const unsigned char * D.32528;
  unsigned char D.32529;
  int D.32530;
  const unsigned char * D.32531;
  unsigned char D.32532;
  int D.32533;
  _Bool D.32534;
  _Bool D.32535;
  const unsigned char * D.32538;
  unsigned char D.32539;
  int D.32540;
  const unsigned char * D.32541;
  unsigned char D.32542;
  int D.32543;
  _Bool D.32544;
  _Bool D.32545;
  const unsigned char * D.32548;
  unsigned char D.32549;
  int D.32550;
  const unsigned char * D.32551;
  unsigned char D.32552;
  int D.32553;
  int D.25122;
  int iftmp.329;
  int D.25121;
  const char[6] * D.32561;
  unsigned char D.32562;
  int D.32563;
  unsigned char D.32564;
  int D.32565;
  _Bool D.32566;
  _Bool D.32567;
  _Bool D.32568;
  const unsigned char * D.32571;
  unsigned char D.32572;
  int D.32573;
  const unsigned char * D.32574;
  unsigned char D.32575;
  int D.32576;
  _Bool D.32577;
  _Bool D.32578;
  const unsigned char * D.32581;
  unsigned char D.32582;
  int D.32583;
  const unsigned char * D.32584;
  unsigned char D.32585;
  int D.32586;
  _Bool D.32587;
  _Bool D.32588;
  const unsigned char * D.32591;
  unsigned char D.32592;
  int D.32593;
  const unsigned char * D.32594;
  unsigned char D.32595;
  int D.32596;
  int D.25131;
  int iftmp.330;
  int D.25130;
  const char[7] * D.32604;
  unsigned char D.32605;
  int D.32606;
  unsigned char D.32607;
  int D.32608;
  _Bool D.32609;
  _Bool D.32610;
  _Bool D.32611;
  const unsigned char * D.32614;
  unsigned char D.32615;
  int D.32616;
  const unsigned char * D.32617;
  unsigned char D.32618;
  int D.32619;
  _Bool D.32620;
  _Bool D.32621;
  const unsigned char * D.32624;
  unsigned char D.32625;
  int D.32626;
  const unsigned char * D.32627;
  unsigned char D.32628;
  int D.32629;
  _Bool D.32630;
  _Bool D.32631;
  const unsigned char * D.32634;
  unsigned char D.32635;
  int D.32636;
  const unsigned char * D.32637;
  unsigned char D.32638;
  int D.32639;
  int D.25140;
  int iftmp.331;
  int D.25139;
  const char[7] * D.32647;
  unsigned char D.32648;
  int D.32649;
  unsigned char D.32650;
  int D.32651;
  _Bool D.32652;
  _Bool D.32653;
  _Bool D.32654;
  const unsigned char * D.32657;
  unsigned char D.32658;
  int D.32659;
  const unsigned char * D.32660;
  unsigned char D.32661;
  int D.32662;
  _Bool D.32663;
  _Bool D.32664;
  const unsigned char * D.32667;
  unsigned char D.32668;
  int D.32669;
  const unsigned char * D.32670;
  unsigned char D.32671;
  int D.32672;
  _Bool D.32673;
  _Bool D.32674;
  const unsigned char * D.32677;
  unsigned char D.32678;
  int D.32679;
  const unsigned char * D.32680;
  unsigned char D.32681;
  int D.32682;
  int D.25149;
  int iftmp.332;
  int D.25148;
  const char[4] * D.32690;
  unsigned char D.32691;
  int D.32692;
  unsigned char D.32693;
  int D.32694;
  _Bool D.32695;
  _Bool D.32696;
  _Bool D.32697;
  const unsigned char * D.32700;
  unsigned char D.32701;
  int D.32702;
  const unsigned char * D.32703;
  unsigned char D.32704;
  int D.32705;
  _Bool D.32706;
  _Bool D.32707;
  const unsigned char * D.32710;
  unsigned char D.32711;
  int D.32712;
  const unsigned char * D.32713;
  unsigned char D.32714;
  int D.32715;
  _Bool D.32716;
  _Bool D.32717;
  const unsigned char * D.32720;
  unsigned char D.32721;
  int D.32722;
  const unsigned char * D.32723;
  unsigned char D.32724;
  int D.32725;
  int D.25158;
  int iftmp.333;
  int D.25157;
  const char[7] * D.32733;
  unsigned char D.32734;
  int D.32735;
  unsigned char D.32736;
  int D.32737;
  _Bool D.32738;
  _Bool D.32739;
  _Bool D.32740;
  const unsigned char * D.32743;
  unsigned char D.32744;
  int D.32745;
  const unsigned char * D.32746;
  unsigned char D.32747;
  int D.32748;
  _Bool D.32749;
  _Bool D.32750;
  const unsigned char * D.32753;
  unsigned char D.32754;
  int D.32755;
  const unsigned char * D.32756;
  unsigned char D.32757;
  int D.32758;
  _Bool D.32759;
  _Bool D.32760;
  const unsigned char * D.32763;
  unsigned char D.32764;
  int D.32765;
  const unsigned char * D.32766;
  unsigned char D.32767;
  int D.32768;
  int D.25167;
  int iftmp.334;
  int D.25166;
  const char[5] * D.32776;
  unsigned char D.32777;
  int D.32778;
  unsigned char D.32779;
  int D.32780;
  _Bool D.32781;
  _Bool D.32782;
  _Bool D.32783;
  const unsigned char * D.32786;
  unsigned char D.32787;
  int D.32788;
  const unsigned char * D.32789;
  unsigned char D.32790;
  int D.32791;
  _Bool D.32792;
  _Bool D.32793;
  const unsigned char * D.32796;
  unsigned char D.32797;
  int D.32798;
  const unsigned char * D.32799;
  unsigned char D.32800;
  int D.32801;
  _Bool D.32802;
  _Bool D.32803;
  const unsigned char * D.32806;
  unsigned char D.32807;
  int D.32808;
  const unsigned char * D.32809;
  unsigned char D.32810;
  int D.32811;
  int D.25176;
  int iftmp.335;
  int D.25175;
  const char[8] * D.32819;
  unsigned char D.32820;
  int D.32821;
  unsigned char D.32822;
  int D.32823;
  _Bool D.32824;
  _Bool D.32825;
  _Bool D.32826;
  const unsigned char * D.32829;
  unsigned char D.32830;
  int D.32831;
  const unsigned char * D.32832;
  unsigned char D.32833;
  int D.32834;
  _Bool D.32835;
  _Bool D.32836;
  const unsigned char * D.32839;
  unsigned char D.32840;
  int D.32841;
  const unsigned char * D.32842;
  unsigned char D.32843;
  int D.32844;
  _Bool D.32845;
  _Bool D.32846;
  const unsigned char * D.32849;
  unsigned char D.32850;
  int D.32851;
  const unsigned char * D.32852;
  unsigned char D.32853;
  int D.32854;
  struct MonoType * D.32859;
  struct MonoClass * klass;

  klass = 0B;
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = typename;
      D.32088 = "int";
      D.32089 = MEM[(const unsigned char *)D.32088];
      D.32090 = (int) D.32089;
      D.32091 = *__s2;
      D.32092 = (int) D.32091;
      __result = D.32090 - D.32092;
      {
        D.32093 = __s2_len != 0;
        D.32094 = __result == 0;
        D.32095 = D.32093 & D.32094;
        if (D.32095 != 0) goto <D.32096>; else goto <D.32097>;
        <D.32096>:
        D.32098 = &MEM[(void *)"int" + 1B];
        D.32099 = *D.32098;
        D.32100 = (int) D.32099;
        D.32101 = __s2 + 1;
        D.32102 = *D.32101;
        D.32103 = (int) D.32102;
        __result = D.32100 - D.32103;
        D.32104 = __s2_len > 1;
        D.32094 = __result == 0;
        D.32105 = D.32104 & D.32094;
        if (D.32105 != 0) goto <D.32106>; else goto <D.32107>;
        <D.32106>:
        D.32108 = &MEM[(void *)"int" + 2B];
        D.32109 = *D.32108;
        D.32110 = (int) D.32109;
        D.32111 = __s2 + 2;
        D.32112 = *D.32111;
        D.32113 = (int) D.32112;
        __result = D.32110 - D.32113;
        D.32114 = __s2_len > 2;
        D.32094 = __result == 0;
        D.32115 = D.32114 & D.32094;
        if (D.32115 != 0) goto <D.32116>; else goto <D.32117>;
        <D.32116>:
        D.32118 = &MEM[(void *)"int" + 3B];
        D.32119 = *D.32118;
        D.32120 = (int) D.32119;
        D.32121 = __s2 + 3;
        D.32122 = *D.32121;
        D.32123 = (int) D.32122;
        __result = D.32120 - D.32123;
        <D.32117>:
        <D.32107>:
        <D.32097>:
      }
      D.25022 = __result;
    }
    iftmp.318 = -D.25022;
    goto <D.32124>;
    <D.32087>:
    iftmp.318 = __builtin_strcmp (typename, "int");
    <D.32124>:
    D.25023 = iftmp.318;
  }
  if (D.25023 == 0) goto <D.32125>; else goto <D.32126>;
  <D.32125>:
  klass = mono_defaults.int_class;
  goto <D.32127>;
  <D.32126>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = typename;
      D.32131 = "ptr";
      D.32132 = MEM[(const unsigned char *)D.32131];
      D.32133 = (int) D.32132;
      D.32134 = *__s2;
      D.32135 = (int) D.32134;
      __result = D.32133 - D.32135;
      {
        D.32136 = __s2_len != 0;
        D.32137 = __result == 0;
        D.32138 = D.32136 & D.32137;
        if (D.32138 != 0) goto <D.32139>; else goto <D.32140>;
        <D.32139>:
        D.32141 = &MEM[(void *)"ptr" + 1B];
        D.32142 = *D.32141;
        D.32143 = (int) D.32142;
        D.32144 = __s2 + 1;
        D.32145 = *D.32144;
        D.32146 = (int) D.32145;
        __result = D.32143 - D.32146;
        D.32147 = __s2_len > 1;
        D.32137 = __result == 0;
        D.32148 = D.32147 & D.32137;
        if (D.32148 != 0) goto <D.32149>; else goto <D.32150>;
        <D.32149>:
        D.32151 = &MEM[(void *)"ptr" + 2B];
        D.32152 = *D.32151;
        D.32153 = (int) D.32152;
        D.32154 = __s2 + 2;
        D.32155 = *D.32154;
        D.32156 = (int) D.32155;
        __result = D.32153 - D.32156;
        D.32157 = __s2_len > 2;
        D.32137 = __result == 0;
        D.32158 = D.32157 & D.32137;
        if (D.32158 != 0) goto <D.32159>; else goto <D.32160>;
        <D.32159>:
        D.32161 = &MEM[(void *)"ptr" + 3B];
        D.32162 = *D.32161;
        D.32163 = (int) D.32162;
        D.32164 = __s2 + 3;
        D.32165 = *D.32164;
        D.32166 = (int) D.32165;
        __result = D.32163 - D.32166;
        <D.32160>:
        <D.32150>:
        <D.32140>:
      }
      D.25031 = __result;
    }
    iftmp.319 = -D.25031;
    goto <D.32167>;
    <D.32130>:
    iftmp.319 = __builtin_strcmp (typename, "ptr");
    <D.32167>:
    D.25032 = iftmp.319;
  }
  if (D.25032 == 0) goto <D.32168>; else goto <D.32169>;
  <D.32168>:
  klass = mono_defaults.int_class;
  goto <D.32170>;
  <D.32169>:
  {
    size_t __s1_len;
    size_t __s2_len;

    __s2_len = 4;
    if (__s2_len <= 3) goto <D.32172>; else goto <D.32173>;
    <D.32172>:
    {
      const unsigned char * __s2;
      int __result;

      __s2 = typename;
      D.32174 = "void";
      D.32175 = MEM[(const unsigned char *)D.32174];
      D.32176 = (int) D.32175;
      D.32177 = *__s2;
      D.32178 = (int) D.32177;
      __result = D.32176 - D.32178;
      {
        D.32179 = __s2_len != 0;
        D.32180 = __result == 0;
        D.32181 = D.32179 & D.32180;
        if (D.32181 != 0) goto <D.32182>; else goto <D.32183>;
        <D.32182>:
        D.32184 = &MEM[(void *)"void" + 1B];
        D.32185 = *D.32184;
        D.32186 = (int) D.32185;
        D.32187 = __s2 + 1;
        D.32188 = *D.32187;
        D.32189 = (int) D.32188;
        __result = D.32186 - D.32189;
        D.32190 = __s2_len > 1;
        D.32180 = __result == 0;
        D.32191 = D.32190 & D.32180;
        if (D.32191 != 0) goto <D.32192>; else goto <D.32193>;
        <D.32192>:
        D.32194 = &MEM[(void *)"void" + 2B];
        D.32195 = *D.32194;
        D.32196 = (int) D.32195;
        D.32197 = __s2 + 2;
        D.32198 = *D.32197;
        D.32199 = (int) D.32198;
        __result = D.32196 - D.32199;
        D.32200 = __s2_len > 2;
        D.32180 = __result == 0;
        D.32201 = D.32200 & D.32180;
        if (D.32201 != 0) goto <D.32202>; else goto <D.32203>;
        <D.32202>:
        D.32204 = &MEM[(void *)"void" + 3B];
        D.32205 = *D.32204;
        D.32206 = (int) D.32205;
        D.32207 = __s2 + 3;
        D.32208 = *D.32207;
        D.32209 = (int) D.32208;
        __result = D.32206 - D.32209;
        <D.32203>:
        <D.32193>:
        <D.32183>:
      }
      D.25040 = __result;
    }
    iftmp.320 = -D.25040;
    goto <D.32210>;
    <D.32173>:
    iftmp.320 = __builtin_strcmp (typename, "void");
    <D.32210>:
    D.25041 = iftmp.320;
  }
  if (D.25041 == 0) goto <D.32211>; else goto <D.32212>;
  <D.32211>:
  klass = mono_defaults.void_class;
  goto <D.32213>;
  <D.32212>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = typename;
      D.32217 = "int32";
      D.32218 = MEM[(const unsigned char *)D.32217];
      D.32219 = (int) D.32218;
      D.32220 = *__s2;
      D.32221 = (int) D.32220;
      __result = D.32219 - D.32221;
      {
        D.32222 = __s2_len != 0;
        D.32223 = __result == 0;
        D.32224 = D.32222 & D.32223;
        if (D.32224 != 0) goto <D.32225>; else goto <D.32226>;
        <D.32225>:
        D.32227 = &MEM[(void *)"int32" + 1B];
        D.32228 = *D.32227;
        D.32229 = (int) D.32228;
        D.32230 = __s2 + 1;
        D.32231 = *D.32230;
        D.32232 = (int) D.32231;
        __result = D.32229 - D.32232;
        D.32233 = __s2_len > 1;
        D.32223 = __result == 0;
        D.32234 = D.32233 & D.32223;
        if (D.32234 != 0) goto <D.32235>; else goto <D.32236>;
        <D.32235>:
        D.32237 = &MEM[(void *)"int32" + 2B];
        D.32238 = *D.32237;
        D.32239 = (int) D.32238;
        D.32240 = __s2 + 2;
        D.32241 = *D.32240;
        D.32242 = (int) D.32241;
        __result = D.32239 - D.32242;
        D.32243 = __s2_len > 2;
        D.32223 = __result == 0;
        D.32244 = D.32243 & D.32223;
        if (D.32244 != 0) goto <D.32245>; else goto <D.32246>;
        <D.32245>:
        D.32247 = &MEM[(void *)"int32" + 3B];
        D.32248 = *D.32247;
        D.32249 = (int) D.32248;
        D.32250 = __s2 + 3;
        D.32251 = *D.32250;
        D.32252 = (int) D.32251;
        __result = D.32249 - D.32252;
        <D.32246>:
        <D.32236>:
        <D.32226>:
      }
      D.25049 = __result;
    }
    iftmp.321 = -D.25049;
    goto <D.32253>;
    <D.32216>:
    iftmp.321 = __builtin_strcmp (typename, "int32");
    <D.32253>:
    D.25050 = iftmp.321;
  }
  if (D.25050 == 0) goto <D.32254>; else goto <D.32255>;
  <D.32254>:
  klass = mono_defaults.int32_class;
  goto <D.32256>;
  <D.32255>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = typename;
      D.32260 = "uint32";
      D.32261 = MEM[(const unsigned char *)D.32260];
      D.32262 = (int) D.32261;
      D.32263 = *__s2;
      D.32264 = (int) D.32263;
      __result = D.32262 - D.32264;
      {
        D.32265 = __s2_len != 0;
        D.32266 = __result == 0;
        D.32267 = D.32265 & D.32266;
        if (D.32267 != 0) goto <D.32268>; else goto <D.32269>;
        <D.32268>:
        D.32270 = &MEM[(void *)"uint32" + 1B];
        D.32271 = *D.32270;
        D.32272 = (int) D.32271;
        D.32273 = __s2 + 1;
        D.32274 = *D.32273;
        D.32275 = (int) D.32274;
        __result = D.32272 - D.32275;
        D.32276 = __s2_len > 1;
        D.32266 = __result == 0;
        D.32277 = D.32276 & D.32266;
        if (D.32277 != 0) goto <D.32278>; else goto <D.32279>;
        <D.32278>:
        D.32280 = &MEM[(void *)"uint32" + 2B];
        D.32281 = *D.32280;
        D.32282 = (int) D.32281;
        D.32283 = __s2 + 2;
        D.32284 = *D.32283;
        D.32285 = (int) D.32284;
        __result = D.32282 - D.32285;
        D.32286 = __s2_len > 2;
        D.32266 = __result == 0;
        D.32287 = D.32286 & D.32266;
        if (D.32287 != 0) goto <D.32288>; else goto <D.32289>;
        <D.32288>:
        D.32290 = &MEM[(void *)"uint32" + 3B];
        D.32291 = *D.32290;
        D.32292 = (int) D.32291;
        D.32293 = __s2 + 3;
        D.32294 = *D.32293;
        D.32295 = (int) D.32294;
        __result = D.32292 - D.32295;
        <D.32289>:
        <D.32279>:
        <D.32269>:
      }
      D.25058 = __result;
    }
    iftmp.322 = -D.25058;
    goto <D.32296>;
    <D.32259>:
    iftmp.322 = __builtin_strcmp (typename, "uint32");
    <D.32296>:
    D.25059 = iftmp.322;
  }
  if (D.25059 == 0) goto <D.32297>; else goto <D.32298>;
  <D.32297>:
  klass = mono_defaults.uint32_class;
  goto <D.32299>;
  <D.32298>:
  {
    size_t __s1_len;
    size_t __s2_len;

    __s2_len = 4;
    if (__s2_len <= 3) goto <D.32301>; else goto <D.32302>;
    <D.32301>:
    {
      const unsigned char * __s2;
      int __result;

      __s2 = typename;
      D.32303 = "int8";
      D.32304 = MEM[(const unsigned char *)D.32303];
      D.32305 = (int) D.32304;
      D.32306 = *__s2;
      D.32307 = (int) D.32306;
      __result = D.32305 - D.32307;
      {
        D.32308 = __s2_len != 0;
        D.32309 = __result == 0;
        D.32310 = D.32308 & D.32309;
        if (D.32310 != 0) goto <D.32311>; else goto <D.32312>;
        <D.32311>:
        D.32313 = &MEM[(void *)"int8" + 1B];
        D.32314 = *D.32313;
        D.32315 = (int) D.32314;
        D.32316 = __s2 + 1;
        D.32317 = *D.32316;
        D.32318 = (int) D.32317;
        __result = D.32315 - D.32318;
        D.32319 = __s2_len > 1;
        D.32309 = __result == 0;
        D.32320 = D.32319 & D.32309;
        if (D.32320 != 0) goto <D.32321>; else goto <D.32322>;
        <D.32321>:
        D.32323 = &MEM[(void *)"int8" + 2B];
        D.32324 = *D.32323;
        D.32325 = (int) D.32324;
        D.32326 = __s2 + 2;
        D.32327 = *D.32326;
        D.32328 = (int) D.32327;
        __result = D.32325 - D.32328;
        D.32329 = __s2_len > 2;
        D.32309 = __result == 0;
        D.32330 = D.32329 & D.32309;
        if (D.32330 != 0) goto <D.32331>; else goto <D.32332>;
        <D.32331>:
        D.32333 = &MEM[(void *)"int8" + 3B];
        D.32334 = *D.32333;
        D.32335 = (int) D.32334;
        D.32336 = __s2 + 3;
        D.32337 = *D.32336;
        D.32338 = (int) D.32337;
        __result = D.32335 - D.32338;
        <D.32332>:
        <D.32322>:
        <D.32312>:
      }
      D.25067 = __result;
    }
    iftmp.323 = -D.25067;
    goto <D.32339>;
    <D.32302>:
    iftmp.323 = __builtin_strcmp (typename, "int8");
    <D.32339>:
    D.25068 = iftmp.323;
  }
  if (D.25068 == 0) goto <D.32340>; else goto <D.32341>;
  <D.32340>:
  klass = mono_defaults.sbyte_class;
  goto <D.32342>;
  <D.32341>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = typename;
      D.32346 = "uint8";
      D.32347 = MEM[(const unsigned char *)D.32346];
      D.32348 = (int) D.32347;
      D.32349 = *__s2;
      D.32350 = (int) D.32349;
      __result = D.32348 - D.32350;
      {
        D.32351 = __s2_len != 0;
        D.32352 = __result == 0;
        D.32353 = D.32351 & D.32352;
        if (D.32353 != 0) goto <D.32354>; else goto <D.32355>;
        <D.32354>:
        D.32356 = &MEM[(void *)"uint8" + 1B];
        D.32357 = *D.32356;
        D.32358 = (int) D.32357;
        D.32359 = __s2 + 1;
        D.32360 = *D.32359;
        D.32361 = (int) D.32360;
        __result = D.32358 - D.32361;
        D.32362 = __s2_len > 1;
        D.32352 = __result == 0;
        D.32363 = D.32362 & D.32352;
        if (D.32363 != 0) goto <D.32364>; else goto <D.32365>;
        <D.32364>:
        D.32366 = &MEM[(void *)"uint8" + 2B];
        D.32367 = *D.32366;
        D.32368 = (int) D.32367;
        D.32369 = __s2 + 2;
        D.32370 = *D.32369;
        D.32371 = (int) D.32370;
        __result = D.32368 - D.32371;
        D.32372 = __s2_len > 2;
        D.32352 = __result == 0;
        D.32373 = D.32372 & D.32352;
        if (D.32373 != 0) goto <D.32374>; else goto <D.32375>;
        <D.32374>:
        D.32376 = &MEM[(void *)"uint8" + 3B];
        D.32377 = *D.32376;
        D.32378 = (int) D.32377;
        D.32379 = __s2 + 3;
        D.32380 = *D.32379;
        D.32381 = (int) D.32380;
        __result = D.32378 - D.32381;
        <D.32375>:
        <D.32365>:
        <D.32355>:
      }
      D.25076 = __result;
    }
    iftmp.324 = -D.25076;
    goto <D.32382>;
    <D.32345>:
    iftmp.324 = __builtin_strcmp (typename, "uint8");
    <D.32382>:
    D.25077 = iftmp.324;
  }
  if (D.25077 == 0) goto <D.32383>; else goto <D.32384>;
  <D.32383>:
  klass = mono_defaults.byte_class;
  goto <D.32385>;
  <D.32384>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = typename;
      D.32389 = "int16";
      D.32390 = MEM[(const unsigned char *)D.32389];
      D.32391 = (int) D.32390;
      D.32392 = *__s2;
      D.32393 = (int) D.32392;
      __result = D.32391 - D.32393;
      {
        D.32394 = __s2_len != 0;
        D.32395 = __result == 0;
        D.32396 = D.32394 & D.32395;
        if (D.32396 != 0) goto <D.32397>; else goto <D.32398>;
        <D.32397>:
        D.32399 = &MEM[(void *)"int16" + 1B];
        D.32400 = *D.32399;
        D.32401 = (int) D.32400;
        D.32402 = __s2 + 1;
        D.32403 = *D.32402;
        D.32404 = (int) D.32403;
        __result = D.32401 - D.32404;
        D.32405 = __s2_len > 1;
        D.32395 = __result == 0;
        D.32406 = D.32405 & D.32395;
        if (D.32406 != 0) goto <D.32407>; else goto <D.32408>;
        <D.32407>:
        D.32409 = &MEM[(void *)"int16" + 2B];
        D.32410 = *D.32409;
        D.32411 = (int) D.32410;
        D.32412 = __s2 + 2;
        D.32413 = *D.32412;
        D.32414 = (int) D.32413;
        __result = D.32411 - D.32414;
        D.32415 = __s2_len > 2;
        D.32395 = __result == 0;
        D.32416 = D.32415 & D.32395;
        if (D.32416 != 0) goto <D.32417>; else goto <D.32418>;
        <D.32417>:
        D.32419 = &MEM[(void *)"int16" + 3B];
        D.32420 = *D.32419;
        D.32421 = (int) D.32420;
        D.32422 = __s2 + 3;
        D.32423 = *D.32422;
        D.32424 = (int) D.32423;
        __result = D.32421 - D.32424;
        <D.32418>:
        <D.32408>:
        <D.32398>:
      }
      D.25085 = __result;
    }
    iftmp.325 = -D.25085;
    goto <D.32425>;
    <D.32388>:
    iftmp.325 = __builtin_strcmp (typename, "int16");
    <D.32425>:
    D.25086 = iftmp.325;
  }
  if (D.25086 == 0) goto <D.32426>; else goto <D.32427>;
  <D.32426>:
  klass = mono_defaults.int16_class;
  goto <D.32428>;
  <D.32427>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = typename;
      D.32432 = "uint16";
      D.32433 = MEM[(const unsigned char *)D.32432];
      D.32434 = (int) D.32433;
      D.32435 = *__s2;
      D.32436 = (int) D.32435;
      __result = D.32434 - D.32436;
      {
        D.32437 = __s2_len != 0;
        D.32438 = __result == 0;
        D.32439 = D.32437 & D.32438;
        if (D.32439 != 0) goto <D.32440>; else goto <D.32441>;
        <D.32440>:
        D.32442 = &MEM[(void *)"uint16" + 1B];
        D.32443 = *D.32442;
        D.32444 = (int) D.32443;
        D.32445 = __s2 + 1;
        D.32446 = *D.32445;
        D.32447 = (int) D.32446;
        __result = D.32444 - D.32447;
        D.32448 = __s2_len > 1;
        D.32438 = __result == 0;
        D.32449 = D.32448 & D.32438;
        if (D.32449 != 0) goto <D.32450>; else goto <D.32451>;
        <D.32450>:
        D.32452 = &MEM[(void *)"uint16" + 2B];
        D.32453 = *D.32452;
        D.32454 = (int) D.32453;
        D.32455 = __s2 + 2;
        D.32456 = *D.32455;
        D.32457 = (int) D.32456;
        __result = D.32454 - D.32457;
        D.32458 = __s2_len > 2;
        D.32438 = __result == 0;
        D.32459 = D.32458 & D.32438;
        if (D.32459 != 0) goto <D.32460>; else goto <D.32461>;
        <D.32460>:
        D.32462 = &MEM[(void *)"uint16" + 3B];
        D.32463 = *D.32462;
        D.32464 = (int) D.32463;
        D.32465 = __s2 + 3;
        D.32466 = *D.32465;
        D.32467 = (int) D.32466;
        __result = D.32464 - D.32467;
        <D.32461>:
        <D.32451>:
        <D.32441>:
      }
      D.25094 = __result;
    }
    iftmp.326 = -D.25094;
    goto <D.32468>;
    <D.32431>:
    iftmp.326 = __builtin_strcmp (typename, "uint16");
    <D.32468>:
    D.25095 = iftmp.326;
  }
  if (D.25095 == 0) goto <D.32469>; else goto <D.32470>;
  <D.32469>:
  klass = mono_defaults.uint16_class;
  goto <D.32471>;
  <D.32470>:
  {
    size_t __s1_len;
    size_t __s2_len;

    __s2_len = 4;
    if (__s2_len <= 3) goto <D.32473>; else goto <D.32474>;
    <D.32473>:
    {
      const unsigned char * __s2;
      int __result;

      __s2 = typename;
      D.32475 = "long";
      D.32476 = MEM[(const unsigned char *)D.32475];
      D.32477 = (int) D.32476;
      D.32478 = *__s2;
      D.32479 = (int) D.32478;
      __result = D.32477 - D.32479;
      {
        D.32480 = __s2_len != 0;
        D.32481 = __result == 0;
        D.32482 = D.32480 & D.32481;
        if (D.32482 != 0) goto <D.32483>; else goto <D.32484>;
        <D.32483>:
        D.32485 = &MEM[(void *)"long" + 1B];
        D.32486 = *D.32485;
        D.32487 = (int) D.32486;
        D.32488 = __s2 + 1;
        D.32489 = *D.32488;
        D.32490 = (int) D.32489;
        __result = D.32487 - D.32490;
        D.32491 = __s2_len > 1;
        D.32481 = __result == 0;
        D.32492 = D.32491 & D.32481;
        if (D.32492 != 0) goto <D.32493>; else goto <D.32494>;
        <D.32493>:
        D.32495 = &MEM[(void *)"long" + 2B];
        D.32496 = *D.32495;
        D.32497 = (int) D.32496;
        D.32498 = __s2 + 2;
        D.32499 = *D.32498;
        D.32500 = (int) D.32499;
        __result = D.32497 - D.32500;
        D.32501 = __s2_len > 2;
        D.32481 = __result == 0;
        D.32502 = D.32501 & D.32481;
        if (D.32502 != 0) goto <D.32503>; else goto <D.32504>;
        <D.32503>:
        D.32505 = &MEM[(void *)"long" + 3B];
        D.32506 = *D.32505;
        D.32507 = (int) D.32506;
        D.32508 = __s2 + 3;
        D.32509 = *D.32508;
        D.32510 = (int) D.32509;
        __result = D.32507 - D.32510;
        <D.32504>:
        <D.32494>:
        <D.32484>:
      }
      D.25103 = __result;
    }
    iftmp.327 = -D.25103;
    goto <D.32511>;
    <D.32474>:
    iftmp.327 = __builtin_strcmp (typename, "long");
    <D.32511>:
    D.25104 = iftmp.327;
  }
  if (D.25104 == 0) goto <D.32512>; else goto <D.32513>;
  <D.32512>:
  klass = mono_defaults.int64_class;
  goto <D.32514>;
  <D.32513>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = typename;
      D.32518 = "ulong";
      D.32519 = MEM[(const unsigned char *)D.32518];
      D.32520 = (int) D.32519;
      D.32521 = *__s2;
      D.32522 = (int) D.32521;
      __result = D.32520 - D.32522;
      {
        D.32523 = __s2_len != 0;
        D.32524 = __result == 0;
        D.32525 = D.32523 & D.32524;
        if (D.32525 != 0) goto <D.32526>; else goto <D.32527>;
        <D.32526>:
        D.32528 = &MEM[(void *)"ulong" + 1B];
        D.32529 = *D.32528;
        D.32530 = (int) D.32529;
        D.32531 = __s2 + 1;
        D.32532 = *D.32531;
        D.32533 = (int) D.32532;
        __result = D.32530 - D.32533;
        D.32534 = __s2_len > 1;
        D.32524 = __result == 0;
        D.32535 = D.32534 & D.32524;
        if (D.32535 != 0) goto <D.32536>; else goto <D.32537>;
        <D.32536>:
        D.32538 = &MEM[(void *)"ulong" + 2B];
        D.32539 = *D.32538;
        D.32540 = (int) D.32539;
        D.32541 = __s2 + 2;
        D.32542 = *D.32541;
        D.32543 = (int) D.32542;
        __result = D.32540 - D.32543;
        D.32544 = __s2_len > 2;
        D.32524 = __result == 0;
        D.32545 = D.32544 & D.32524;
        if (D.32545 != 0) goto <D.32546>; else goto <D.32547>;
        <D.32546>:
        D.32548 = &MEM[(void *)"ulong" + 3B];
        D.32549 = *D.32548;
        D.32550 = (int) D.32549;
        D.32551 = __s2 + 3;
        D.32552 = *D.32551;
        D.32553 = (int) D.32552;
        __result = D.32550 - D.32553;
        <D.32547>:
        <D.32537>:
        <D.32527>:
      }
      D.25112 = __result;
    }
    iftmp.328 = -D.25112;
    goto <D.32554>;
    <D.32517>:
    iftmp.328 = __builtin_strcmp (typename, "ulong");
    <D.32554>:
    D.25113 = iftmp.328;
  }
  if (D.25113 == 0) goto <D.32555>; else goto <D.32556>;
  <D.32555>:
  klass = mono_defaults.uint64_class;
  goto <D.32557>;
  <D.32556>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = typename;
      D.32561 = "float";
      D.32562 = MEM[(const unsigned char *)D.32561];
      D.32563 = (int) D.32562;
      D.32564 = *__s2;
      D.32565 = (int) D.32564;
      __result = D.32563 - D.32565;
      {
        D.32566 = __s2_len != 0;
        D.32567 = __result == 0;
        D.32568 = D.32566 & D.32567;
        if (D.32568 != 0) goto <D.32569>; else goto <D.32570>;
        <D.32569>:
        D.32571 = &MEM[(void *)"float" + 1B];
        D.32572 = *D.32571;
        D.32573 = (int) D.32572;
        D.32574 = __s2 + 1;
        D.32575 = *D.32574;
        D.32576 = (int) D.32575;
        __result = D.32573 - D.32576;
        D.32577 = __s2_len > 1;
        D.32567 = __result == 0;
        D.32578 = D.32577 & D.32567;
        if (D.32578 != 0) goto <D.32579>; else goto <D.32580>;
        <D.32579>:
        D.32581 = &MEM[(void *)"float" + 2B];
        D.32582 = *D.32581;
        D.32583 = (int) D.32582;
        D.32584 = __s2 + 2;
        D.32585 = *D.32584;
        D.32586 = (int) D.32585;
        __result = D.32583 - D.32586;
        D.32587 = __s2_len > 2;
        D.32567 = __result == 0;
        D.32588 = D.32587 & D.32567;
        if (D.32588 != 0) goto <D.32589>; else goto <D.32590>;
        <D.32589>:
        D.32591 = &MEM[(void *)"float" + 3B];
        D.32592 = *D.32591;
        D.32593 = (int) D.32592;
        D.32594 = __s2 + 3;
        D.32595 = *D.32594;
        D.32596 = (int) D.32595;
        __result = D.32593 - D.32596;
        <D.32590>:
        <D.32580>:
        <D.32570>:
      }
      D.25121 = __result;
    }
    iftmp.329 = -D.25121;
    goto <D.32597>;
    <D.32560>:
    iftmp.329 = __builtin_strcmp (typename, "float");
    <D.32597>:
    D.25122 = iftmp.329;
  }
  if (D.25122 == 0) goto <D.32598>; else goto <D.32599>;
  <D.32598>:
  klass = mono_defaults.single_class;
  goto <D.32600>;
  <D.32599>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = typename;
      D.32604 = "double";
      D.32605 = MEM[(const unsigned char *)D.32604];
      D.32606 = (int) D.32605;
      D.32607 = *__s2;
      D.32608 = (int) D.32607;
      __result = D.32606 - D.32608;
      {
        D.32609 = __s2_len != 0;
        D.32610 = __result == 0;
        D.32611 = D.32609 & D.32610;
        if (D.32611 != 0) goto <D.32612>; else goto <D.32613>;
        <D.32612>:
        D.32614 = &MEM[(void *)"double" + 1B];
        D.32615 = *D.32614;
        D.32616 = (int) D.32615;
        D.32617 = __s2 + 1;
        D.32618 = *D.32617;
        D.32619 = (int) D.32618;
        __result = D.32616 - D.32619;
        D.32620 = __s2_len > 1;
        D.32610 = __result == 0;
        D.32621 = D.32620 & D.32610;
        if (D.32621 != 0) goto <D.32622>; else goto <D.32623>;
        <D.32622>:
        D.32624 = &MEM[(void *)"double" + 2B];
        D.32625 = *D.32624;
        D.32626 = (int) D.32625;
        D.32627 = __s2 + 2;
        D.32628 = *D.32627;
        D.32629 = (int) D.32628;
        __result = D.32626 - D.32629;
        D.32630 = __s2_len > 2;
        D.32610 = __result == 0;
        D.32631 = D.32630 & D.32610;
        if (D.32631 != 0) goto <D.32632>; else goto <D.32633>;
        <D.32632>:
        D.32634 = &MEM[(void *)"double" + 3B];
        D.32635 = *D.32634;
        D.32636 = (int) D.32635;
        D.32637 = __s2 + 3;
        D.32638 = *D.32637;
        D.32639 = (int) D.32638;
        __result = D.32636 - D.32639;
        <D.32633>:
        <D.32623>:
        <D.32613>:
      }
      D.25130 = __result;
    }
    iftmp.330 = -D.25130;
    goto <D.32640>;
    <D.32603>:
    iftmp.330 = __builtin_strcmp (typename, "double");
    <D.32640>:
    D.25131 = iftmp.330;
  }
  if (D.25131 == 0) goto <D.32641>; else goto <D.32642>;
  <D.32641>:
  klass = mono_defaults.double_class;
  goto <D.32643>;
  <D.32642>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = typename;
      D.32647 = "object";
      D.32648 = MEM[(const unsigned char *)D.32647];
      D.32649 = (int) D.32648;
      D.32650 = *__s2;
      D.32651 = (int) D.32650;
      __result = D.32649 - D.32651;
      {
        D.32652 = __s2_len != 0;
        D.32653 = __result == 0;
        D.32654 = D.32652 & D.32653;
        if (D.32654 != 0) goto <D.32655>; else goto <D.32656>;
        <D.32655>:
        D.32657 = &MEM[(void *)"object" + 1B];
        D.32658 = *D.32657;
        D.32659 = (int) D.32658;
        D.32660 = __s2 + 1;
        D.32661 = *D.32660;
        D.32662 = (int) D.32661;
        __result = D.32659 - D.32662;
        D.32663 = __s2_len > 1;
        D.32653 = __result == 0;
        D.32664 = D.32663 & D.32653;
        if (D.32664 != 0) goto <D.32665>; else goto <D.32666>;
        <D.32665>:
        D.32667 = &MEM[(void *)"object" + 2B];
        D.32668 = *D.32667;
        D.32669 = (int) D.32668;
        D.32670 = __s2 + 2;
        D.32671 = *D.32670;
        D.32672 = (int) D.32671;
        __result = D.32669 - D.32672;
        D.32673 = __s2_len > 2;
        D.32653 = __result == 0;
        D.32674 = D.32673 & D.32653;
        if (D.32674 != 0) goto <D.32675>; else goto <D.32676>;
        <D.32675>:
        D.32677 = &MEM[(void *)"object" + 3B];
        D.32678 = *D.32677;
        D.32679 = (int) D.32678;
        D.32680 = __s2 + 3;
        D.32681 = *D.32680;
        D.32682 = (int) D.32681;
        __result = D.32679 - D.32682;
        <D.32676>:
        <D.32666>:
        <D.32656>:
      }
      D.25139 = __result;
    }
    iftmp.331 = -D.25139;
    goto <D.32683>;
    <D.32646>:
    iftmp.331 = __builtin_strcmp (typename, "object");
    <D.32683>:
    D.25140 = iftmp.331;
  }
  if (D.25140 == 0) goto <D.32684>; else goto <D.32685>;
  <D.32684>:
  klass = mono_defaults.object_class;
  goto <D.32686>;
  <D.32685>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = typename;
      D.32690 = "obj";
      D.32691 = MEM[(const unsigned char *)D.32690];
      D.32692 = (int) D.32691;
      D.32693 = *__s2;
      D.32694 = (int) D.32693;
      __result = D.32692 - D.32694;
      {
        D.32695 = __s2_len != 0;
        D.32696 = __result == 0;
        D.32697 = D.32695 & D.32696;
        if (D.32697 != 0) goto <D.32698>; else goto <D.32699>;
        <D.32698>:
        D.32700 = &MEM[(void *)"obj" + 1B];
        D.32701 = *D.32700;
        D.32702 = (int) D.32701;
        D.32703 = __s2 + 1;
        D.32704 = *D.32703;
        D.32705 = (int) D.32704;
        __result = D.32702 - D.32705;
        D.32706 = __s2_len > 1;
        D.32696 = __result == 0;
        D.32707 = D.32706 & D.32696;
        if (D.32707 != 0) goto <D.32708>; else goto <D.32709>;
        <D.32708>:
        D.32710 = &MEM[(void *)"obj" + 2B];
        D.32711 = *D.32710;
        D.32712 = (int) D.32711;
        D.32713 = __s2 + 2;
        D.32714 = *D.32713;
        D.32715 = (int) D.32714;
        __result = D.32712 - D.32715;
        D.32716 = __s2_len > 2;
        D.32696 = __result == 0;
        D.32717 = D.32716 & D.32696;
        if (D.32717 != 0) goto <D.32718>; else goto <D.32719>;
        <D.32718>:
        D.32720 = &MEM[(void *)"obj" + 3B];
        D.32721 = *D.32720;
        D.32722 = (int) D.32721;
        D.32723 = __s2 + 3;
        D.32724 = *D.32723;
        D.32725 = (int) D.32724;
        __result = D.32722 - D.32725;
        <D.32719>:
        <D.32709>:
        <D.32699>:
      }
      D.25148 = __result;
    }
    iftmp.332 = -D.25148;
    goto <D.32726>;
    <D.32689>:
    iftmp.332 = __builtin_strcmp (typename, "obj");
    <D.32726>:
    D.25149 = iftmp.332;
  }
  if (D.25149 == 0) goto <D.32727>; else goto <D.32728>;
  <D.32727>:
  klass = mono_defaults.object_class;
  goto <D.32729>;
  <D.32728>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = typename;
      D.32733 = "string";
      D.32734 = MEM[(const unsigned char *)D.32733];
      D.32735 = (int) D.32734;
      D.32736 = *__s2;
      D.32737 = (int) D.32736;
      __result = D.32735 - D.32737;
      {
        D.32738 = __s2_len != 0;
        D.32739 = __result == 0;
        D.32740 = D.32738 & D.32739;
        if (D.32740 != 0) goto <D.32741>; else goto <D.32742>;
        <D.32741>:
        D.32743 = &MEM[(void *)"string" + 1B];
        D.32744 = *D.32743;
        D.32745 = (int) D.32744;
        D.32746 = __s2 + 1;
        D.32747 = *D.32746;
        D.32748 = (int) D.32747;
        __result = D.32745 - D.32748;
        D.32749 = __s2_len > 1;
        D.32739 = __result == 0;
        D.32750 = D.32749 & D.32739;
        if (D.32750 != 0) goto <D.32751>; else goto <D.32752>;
        <D.32751>:
        D.32753 = &MEM[(void *)"string" + 2B];
        D.32754 = *D.32753;
        D.32755 = (int) D.32754;
        D.32756 = __s2 + 2;
        D.32757 = *D.32756;
        D.32758 = (int) D.32757;
        __result = D.32755 - D.32758;
        D.32759 = __s2_len > 2;
        D.32739 = __result == 0;
        D.32760 = D.32759 & D.32739;
        if (D.32760 != 0) goto <D.32761>; else goto <D.32762>;
        <D.32761>:
        D.32763 = &MEM[(void *)"string" + 3B];
        D.32764 = *D.32763;
        D.32765 = (int) D.32764;
        D.32766 = __s2 + 3;
        D.32767 = *D.32766;
        D.32768 = (int) D.32767;
        __result = D.32765 - D.32768;
        <D.32762>:
        <D.32752>:
        <D.32742>:
      }
      D.25157 = __result;
    }
    iftmp.333 = -D.25157;
    goto <D.32769>;
    <D.32732>:
    iftmp.333 = __builtin_strcmp (typename, "string");
    <D.32769>:
    D.25158 = iftmp.333;
  }
  if (D.25158 == 0) goto <D.32770>; else goto <D.32771>;
  <D.32770>:
  klass = mono_defaults.string_class;
  goto <D.32772>;
  <D.32771>:
  {
    size_t __s1_len;
    size_t __s2_len;

    __s2_len = 4;
    if (__s2_len <= 3) goto <D.32774>; else goto <D.32775>;
    <D.32774>:
    {
      const unsigned char * __s2;
      int __result;

      __s2 = typename;
      D.32776 = "bool";
      D.32777 = MEM[(const unsigned char *)D.32776];
      D.32778 = (int) D.32777;
      D.32779 = *__s2;
      D.32780 = (int) D.32779;
      __result = D.32778 - D.32780;
      {
        D.32781 = __s2_len != 0;
        D.32782 = __result == 0;
        D.32783 = D.32781 & D.32782;
        if (D.32783 != 0) goto <D.32784>; else goto <D.32785>;
        <D.32784>:
        D.32786 = &MEM[(void *)"bool" + 1B];
        D.32787 = *D.32786;
        D.32788 = (int) D.32787;
        D.32789 = __s2 + 1;
        D.32790 = *D.32789;
        D.32791 = (int) D.32790;
        __result = D.32788 - D.32791;
        D.32792 = __s2_len > 1;
        D.32782 = __result == 0;
        D.32793 = D.32792 & D.32782;
        if (D.32793 != 0) goto <D.32794>; else goto <D.32795>;
        <D.32794>:
        D.32796 = &MEM[(void *)"bool" + 2B];
        D.32797 = *D.32796;
        D.32798 = (int) D.32797;
        D.32799 = __s2 + 2;
        D.32800 = *D.32799;
        D.32801 = (int) D.32800;
        __result = D.32798 - D.32801;
        D.32802 = __s2_len > 2;
        D.32782 = __result == 0;
        D.32803 = D.32802 & D.32782;
        if (D.32803 != 0) goto <D.32804>; else goto <D.32805>;
        <D.32804>:
        D.32806 = &MEM[(void *)"bool" + 3B];
        D.32807 = *D.32806;
        D.32808 = (int) D.32807;
        D.32809 = __s2 + 3;
        D.32810 = *D.32809;
        D.32811 = (int) D.32810;
        __result = D.32808 - D.32811;
        <D.32805>:
        <D.32795>:
        <D.32785>:
      }
      D.25166 = __result;
    }
    iftmp.334 = -D.25166;
    goto <D.32812>;
    <D.32775>:
    iftmp.334 = __builtin_strcmp (typename, "bool");
    <D.32812>:
    D.25167 = iftmp.334;
  }
  if (D.25167 == 0) goto <D.32813>; else goto <D.32814>;
  <D.32813>:
  klass = mono_defaults.boolean_class;
  goto <D.32815>;
  <D.32814>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = typename;
      D.32819 = "boolean";
      D.32820 = MEM[(const unsigned char *)D.32819];
      D.32821 = (int) D.32820;
      D.32822 = *__s2;
      D.32823 = (int) D.32822;
      __result = D.32821 - D.32823;
      {
        D.32824 = __s2_len != 0;
        D.32825 = __result == 0;
        D.32826 = D.32824 & D.32825;
        if (D.32826 != 0) goto <D.32827>; else goto <D.32828>;
        <D.32827>:
        D.32829 = &MEM[(void *)"boolean" + 1B];
        D.32830 = *D.32829;
        D.32831 = (int) D.32830;
        D.32832 = __s2 + 1;
        D.32833 = *D.32832;
        D.32834 = (int) D.32833;
        __result = D.32831 - D.32834;
        D.32835 = __s2_len > 1;
        D.32825 = __result == 0;
        D.32836 = D.32835 & D.32825;
        if (D.32836 != 0) goto <D.32837>; else goto <D.32838>;
        <D.32837>:
        D.32839 = &MEM[(void *)"boolean" + 2B];
        D.32840 = *D.32839;
        D.32841 = (int) D.32840;
        D.32842 = __s2 + 2;
        D.32843 = *D.32842;
        D.32844 = (int) D.32843;
        __result = D.32841 - D.32844;
        D.32845 = __s2_len > 2;
        D.32825 = __result == 0;
        D.32846 = D.32845 & D.32825;
        if (D.32846 != 0) goto <D.32847>; else goto <D.32848>;
        <D.32847>:
        D.32849 = &MEM[(void *)"boolean" + 3B];
        D.32850 = *D.32849;
        D.32851 = (int) D.32850;
        D.32852 = __s2 + 3;
        D.32853 = *D.32852;
        D.32854 = (int) D.32853;
        __result = D.32851 - D.32854;
        <D.32848>:
        <D.32838>:
        <D.32828>:
      }
      D.25175 = __result;
    }
    iftmp.335 = -D.25175;
    goto <D.32855>;
    <D.32818>:
    iftmp.335 = __builtin_strcmp (typename, "boolean");
    <D.32855>:
    D.25176 = iftmp.335;
  }
  if (D.25176 == 0) goto <D.32856>; else goto <D.32857>;
  <D.32856>:
  klass = mono_defaults.boolean_class;
  goto <D.32858>;
  <D.32857>:
  monoeg_g_log (0B, 4, "%s", typename);
  <D.25177>:
  goto <D.25177>;
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "icall.c", 8265);
  <D.32858>:
  <D.32815>:
  <D.32772>:
  <D.32729>:
  <D.32686>:
  <D.32643>:
  <D.32600>:
  <D.32557>:
  <D.32514>:
  <D.32471>:
  <D.32428>:
  <D.32385>:
  <D.32342>:
  <D.32299>:
  <D.32256>:
  <D.32213>:
  <D.32170>:
  <D.32127>:
  D.32859 = &klass->byval_arg;
  return D.32859;
}


mono_find_jit_icall_by_name (const char * name)
{
  struct GHashTable * jit_icall_hash_name.336;
  _Bool D.32862;
  long int D.32863;
  long int D.32864;
  struct MonoJitICallInfo * D.32867;
  struct MonoJitICallInfo * info;

  jit_icall_hash_name.336 = jit_icall_hash_name;
  D.32862 = jit_icall_hash_name.336 == 0B;
  D.32863 = (long int) D.32862;
  D.32864 = __builtin_expect (D.32863, 0);
  if (D.32864 != 0) goto <D.32865>; else goto <D.32866>;
  <D.32865>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "icall.c", 8331, "jit_icall_hash_name");
  <D.32866>:
  mono_icall_lock ();
  jit_icall_hash_name.336 = jit_icall_hash_name;
  info = monoeg_g_hash_table_lookup (jit_icall_hash_name.336, name);
  mono_icall_unlock ();
  D.32867 = info;
  return D.32867;
}


mono_find_jit_icall_by_addr (const void * addr)
{
  struct GHashTable * jit_icall_hash_addr.337;
  _Bool D.32870;
  long int D.32871;
  long int D.32872;
  struct MonoJitICallInfo * D.32875;
  struct MonoJitICallInfo * info;

  jit_icall_hash_addr.337 = jit_icall_hash_addr;
  D.32870 = jit_icall_hash_addr.337 == 0B;
  D.32871 = (long int) D.32870;
  D.32872 = __builtin_expect (D.32871, 0);
  if (D.32872 != 0) goto <D.32873>; else goto <D.32874>;
  <D.32873>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "icall.c", 8343, "jit_icall_hash_addr");
  <D.32874>:
  mono_icall_lock ();
  jit_icall_hash_addr.337 = jit_icall_hash_addr;
  info = monoeg_g_hash_table_lookup (jit_icall_hash_addr.337, addr);
  mono_icall_unlock ();
  D.32875 = info;
  return D.32875;
}


mono_get_jit_icall_info ()
{
  struct GHashTable * D.32877;

  D.32877 = jit_icall_hash_name;
  return D.32877;
}


mono_lookup_jit_icall_symbol (const char * name)
{
  struct GHashTable * jit_icall_hash_name.338;
  const char * D.32882;
  struct MonoJitICallInfo * info;
  const char * res;

  res = 0B;
  mono_icall_lock ();
  jit_icall_hash_name.338 = jit_icall_hash_name;
  info = monoeg_g_hash_table_lookup (jit_icall_hash_name.338, name);
  if (info != 0B) goto <D.32880>; else goto <D.32881>;
  <D.32880>:
  res = info->c_symbol;
  <D.32881>:
  mono_icall_unlock ();
  D.32882 = res;
  return D.32882;
}


mono_register_jit_icall_wrapper (struct MonoJitICallInfo * info, const void * wrapper)
{
  struct GHashTable * jit_icall_hash_addr.339;

  mono_icall_lock ();
  jit_icall_hash_addr.339 = jit_icall_hash_addr;
  monoeg_g_hash_table_insert_replace (jit_icall_hash_addr.339, 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.32885;
  long int D.32886;
  long int D.32887;
  _Bool D.32890;
  long int D.32891;
  long int D.32892;
  struct GHashTable * jit_icall_hash_name.340;
  struct GHashTable * jit_icall_hash_name.341;
  struct GHashTable * jit_icall_hash_addr.342;
  void * D.32900;
  const char * D.32906;
  struct GHashTable * jit_icall_hash_addr.343;
  struct MonoJitICallInfo * D.32908;
  struct MonoJitICallInfo * info;

  D.32885 = func == 0B;
  D.32886 = (long int) D.32885;
  D.32887 = __builtin_expect (D.32886, 0);
  if (D.32887 != 0) goto <D.32888>; else goto <D.32889>;
  <D.32888>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "icall.c", 8396, "func");
  <D.32889>:
  D.32890 = name == 0B;
  D.32891 = (long int) D.32890;
  D.32892 = __builtin_expect (D.32891, 0);
  if (D.32892 != 0) goto <D.32893>; else goto <D.32894>;
  <D.32893>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "icall.c", 8397, "name");
  <D.32894>:
  mono_icall_lock ();
  jit_icall_hash_name.340 = jit_icall_hash_name;
  if (jit_icall_hash_name.340 == 0B) goto <D.32896>; else goto <D.32897>;
  <D.32896>:
  jit_icall_hash_name.341 = 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.341;
  jit_icall_hash_addr.342 = monoeg_g_hash_table_new (0B, 0B);
  jit_icall_hash_addr = jit_icall_hash_addr.342;
  <D.32897>:
  jit_icall_hash_name.340 = jit_icall_hash_name;
  D.32900 = monoeg_g_hash_table_lookup (jit_icall_hash_name.340, name);
  if (D.32900 != 0B) goto <D.32901>; else goto <D.32902>;
  <D.32901>:
  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.32902>:
  info = monoeg_malloc0 (24);
  info->name = name;
  info->func = func;
  info->sig = sig;
  info->c_symbol = c_symbol;
  if (is_save != 0) goto <D.32903>; else goto <D.32904>;
  <D.32903>:
  info->wrapper = func;
  goto <D.32905>;
  <D.32904>:
  info->wrapper = 0B;
  <D.32905>:
  D.32906 = info->name;
  jit_icall_hash_name.340 = jit_icall_hash_name;
  monoeg_g_hash_table_insert_replace (jit_icall_hash_name.340, D.32906, info, 0);
  jit_icall_hash_addr.343 = jit_icall_hash_addr;
  monoeg_g_hash_table_insert_replace (jit_icall_hash_addr.343, func, info, 0);
  mono_icall_unlock ();
  D.32908 = info;
  return D.32908;
}


mono_register_jit_icall (const void * func, const char * name, struct MonoMethodSignature * sig, gboolean is_save)
{
  struct MonoJitICallInfo * D.32910;

  D.32910 = mono_register_jit_icall_full (func, name, sig, is_save, 0B);
  return D.32910;
}