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 int D.25207;
  unsigned int D.25208;
  int D.21841;
  int iftmp.1;
  int D.21840;
  const char[7] * D.25216;
  unsigned char D.25217;
  int D.25218;
  unsigned char D.25219;
  int D.25220;
  const unsigned char * D.25225;
  unsigned char D.25226;
  int D.25227;
  const unsigned char * D.25228;
  unsigned char D.25229;
  int D.25230;
  const unsigned char * D.25235;
  unsigned char D.25236;
  int D.25237;
  const unsigned char * D.25238;
  unsigned char D.25239;
  int D.25240;
  const unsigned char * D.25245;
  unsigned char D.25246;
  int D.25247;
  const unsigned char * D.25248;
  unsigned char D.25249;
  int D.25250;
  struct MonoLoaderError * D.25256;
  struct GPtrArray * D.25258;
  unsigned char D.25259;
  struct MonoLoaderError * D.25261;
  struct MonoType * D.25263;
  unsigned char D.25264;
  struct MonoClass * D.25267;
  int iftmp.2;
  unsigned int D.25273;
  unsigned int D.25274;
  unsigned char D.25276;
  unsigned int nslots.3;
  int D.25281;
  int D.25282;
  unsigned int D.25283;
  unsigned int D.25284;
  struct MonoLoaderError * D.25287;
  short int D.25289;
  int D.25292;
  _Bool D.25293;
  long int D.25294;
  long int D.25295;
  short int D.25298;
  unsigned int D.25299;
  unsigned int D.25300;
  guint32 * D.25301;
  unsigned int D.25302;
  unsigned short D.25303;
  int D.25304;
  int D.25305;
  int D.25306;
  unsigned int D.25307;
  unsigned int D.25308;
  short unsigned int D.25311;
  int D.25312;
  int D.25313;
  unsigned int D.25316;
  const char * D.25321;
  char D.25322;
  int D.21853;
  int iftmp.4;
  int D.21852;
  const char[6] * D.25328;
  unsigned char D.25329;
  int D.25330;
  unsigned char D.25331;
  int D.25332;
  const unsigned char * D.25337;
  unsigned char D.25338;
  int D.25339;
  const unsigned char * D.25340;
  unsigned char D.25341;
  int D.25342;
  const unsigned char * D.25347;
  unsigned char D.25348;
  int D.25349;
  const unsigned char * D.25350;
  unsigned char D.25351;
  int D.25352;
  const unsigned char * D.25357;
  unsigned char D.25358;
  int D.25359;
  const unsigned char * D.25360;
  unsigned char D.25361;
  int D.25362;
  int D.21862;
  int iftmp.5;
  int D.21861;
  const char[7] * D.25368;
  unsigned char D.25369;
  int D.25370;
  unsigned char D.25371;
  int D.25372;
  const unsigned char * D.25377;
  unsigned char D.25378;
  int D.25379;
  const unsigned char * D.25380;
  unsigned char D.25381;
  int D.25382;
  const unsigned char * D.25387;
  unsigned char D.25388;
  int D.25389;
  const unsigned char * D.25390;
  unsigned char D.25391;
  int D.25392;
  const unsigned char * D.25397;
  unsigned char D.25398;
  int D.25399;
  const unsigned char * D.25400;
  unsigned char D.25401;
  int D.25402;
  int D.25404;
  unsigned int D.25407;
  unsigned int D.25411;
  _Bool D.25414;
  int D.25415;
  int D.25416;
  int D.25421;
  unsigned int D.25424;
  unsigned int D.25429;
  unsigned int D.25432;
  int D.25439;
  unsigned int D.25442;
  struct MonoException * D.25452;
  struct MonoLoaderError * D.25454;
  struct MonoException * D.25455;
  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.25201>; else goto <D.25202>;
      <D.25201>:
      if (ignore_case != 0) goto <D.25204>; else goto <D.25205>;
      <D.25204>:
      iftmp.0 = monoeg_ascii_strcasecmp;
      goto <D.25206>;
      <D.25205>:
      iftmp.0 = strcmp;
      <D.25206>:
      compare_func = iftmp.0;
      <D.25202>:
      D.25207 = BIT_FIELD_REF <*klass, 32, 160>;
      D.25208 = D.25207 & 16777216;
      if (D.25208 != 0) goto <D.25209>; else goto <D.25210>;
      <D.25209>:
      if (name != 0B) goto <D.25211>; else goto <D.25212>;
      <D.25211>:
      {
        size_t __s1_len;
        size_t __s2_len;

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

          __s2 = name;
          D.25216 = "Invoke";
          D.25217 = MEM[(const unsigned char *)D.25216];
          D.25218 = (int) D.25217;
          D.25219 = *__s2;
          D.25220 = (int) D.25219;
          __result = D.25218 - D.25220;
          {
            if (__s2_len != 0) goto <D.25221>; else goto <D.25222>;
            <D.25221>:
            if (__result == 0) goto <D.25223>; else goto <D.25224>;
            <D.25223>:
            D.25225 = &MEM[(void *)"Invoke" + 1B];
            D.25226 = *D.25225;
            D.25227 = (int) D.25226;
            D.25228 = __s2 + 1;
            D.25229 = *D.25228;
            D.25230 = (int) D.25229;
            __result = D.25227 - D.25230;
            if (__s2_len > 1) goto <D.25231>; else goto <D.25232>;
            <D.25231>:
            if (__result == 0) goto <D.25233>; else goto <D.25234>;
            <D.25233>:
            D.25235 = &MEM[(void *)"Invoke" + 2B];
            D.25236 = *D.25235;
            D.25237 = (int) D.25236;
            D.25238 = __s2 + 2;
            D.25239 = *D.25238;
            D.25240 = (int) D.25239;
            __result = D.25237 - D.25240;
            if (__s2_len > 2) goto <D.25241>; else goto <D.25242>;
            <D.25241>:
            if (__result == 0) goto <D.25243>; else goto <D.25244>;
            <D.25243>:
            D.25245 = &MEM[(void *)"Invoke" + 3B];
            D.25246 = *D.25245;
            D.25247 = (int) D.25246;
            D.25248 = __s2 + 3;
            D.25249 = *D.25248;
            D.25250 = (int) D.25249;
            __result = D.25247 - D.25250;
            <D.25244>:
            <D.25242>:
            <D.25234>:
            <D.25232>:
            <D.25224>:
            <D.25222>:
          }
          D.21840 = __result;
        }
        iftmp.1 = -D.21840;
        goto <D.25251>;
        <D.25215>:
        iftmp.1 = __builtin_strcmp (name, "Invoke");
        <D.25251>:
        D.21841 = iftmp.1;
      }
      if (D.21841 == 0) goto <D.25252>; else goto <D.25253>;
      <D.25252>:
      if (bflags == 28) goto <D.25254>; else goto <D.25255>;
      <D.25254>:
      method = mono_get_delegate_invoke (klass);
      D.25256 = mono_loader_get_last_error ();
      if (D.25256 != 0B) goto loader_error; else goto <D.25257>;
      <D.25257>:
      monoeg_g_ptr_array_add (array, method);
      D.25258 = array;
      return D.25258;
      <D.25255>:
      <D.25253>:
      <D.25212>:
      <D.25210>:
      mono_class_setup_vtable (klass);
      D.25259 = klass->exception_type;
      if (D.25259 != 0) goto loader_error; else goto <D.25260>;
      <D.25260>:
      D.25261 = mono_loader_get_last_error ();
      if (D.25261 != 0B) goto loader_error; else goto <D.25262>;
      <D.25262>:
      D.25263 = &klass->byval_arg;
      D.25264 = is_generic_parameter (D.25263);
      if (D.25264 != 0) goto <D.25265>; else goto <D.25266>;
      <D.25265>:
      D.25267 = klass->parent;
      nslots = mono_class_get_vtable_size (D.25267);
      goto <D.25268>;
      <D.25266>:
      D.25273 = klass->flags;
      D.25274 = D.25273 & 32;
      if (D.25274 != 0) goto <D.25270>; else goto <D.25275>;
      <D.25275>:
      D.25276 = klass->byval_arg.type;
      if (D.25276 == 19) goto <D.25270>; else goto <D.25277>;
      <D.25277>:
      D.25276 = klass->byval_arg.type;
      if (D.25276 == 30) goto <D.25270>; else goto <D.25271>;
      <D.25270>:
      iftmp.2 = mono_class_num_methods (klass);
      goto <D.25272>;
      <D.25271>:
      iftmp.2 = mono_class_get_vtable_size (klass);
      <D.25272>:
      nslots = iftmp.2;
      <D.25268>:
      nslots.3 = (unsigned int) nslots;
      if (nslots.3 > 255) goto <D.25279>; else goto <D.25280>;
      <D.25279>:
      D.25281 = nslots / 32;
      D.25282 = D.25281 + 1;
      D.25283 = (unsigned int) D.25282;
      D.25284 = D.25283 * 4;
      method_slots = monoeg_malloc0 (D.25284);
      goto <D.25285>;
      <D.25280>:
      method_slots = &method_slots_default;
      memset (method_slots, 0, 32);
      <D.25285>:
      handle_parent:
      mono_class_setup_vtable (klass);
      D.25259 = klass->exception_type;
      if (D.25259 != 0) goto loader_error; else goto <D.25286>;
      <D.25286>:
      D.25287 = mono_loader_get_last_error ();
      if (D.25287 != 0B) goto loader_error; else goto <D.25288>;
      <D.25288>:
      iter = 0B;
      goto <D.21844>;
      <D.21863>:
      match = 0;
      D.25289 = method->slot;
      if (D.25289 != -1) goto <D.25290>; else goto <D.25291>;
      <D.25290>:
      D.25289 = method->slot;
      D.25292 = (int) D.25289;
      D.25293 = D.25292 >= nslots;
      D.25294 = (long int) D.25293;
      D.25295 = __builtin_expect (D.25294, 0);
      if (D.25295 != 0) goto <D.25296>; else goto <D.25297>;
      <D.25296>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "icall.c", 3493, "method->slot < nslots");
      <D.25297>:
      D.25289 = method->slot;
      D.25298 = D.25289 >> 5;
      D.25299 = (unsigned int) D.25298;
      D.25300 = D.25299 * 4;
      D.25301 = method_slots + D.25300;
      D.25302 = *D.25301;
      D.25289 = method->slot;
      D.25303 = (unsigned short) D.25289;
      D.25304 = (int) D.25303;
      D.25305 = D.25304 & 31;
      D.25306 = 1 << D.25305;
      D.25307 = (unsigned int) D.25306;
      D.25308 = D.25302 & D.25307;
      if (D.25308 != 0) goto <D.25309>; else goto <D.25310>;
      <D.25309>:
      // predicted unlikely by continue predictor.
      goto <D.21844>;
      <D.25310>:
      D.25311 = method->flags;
      D.25312 = (int) D.25311;
      D.25313 = D.25312 & 256;
      if (D.25313 == 0) goto <D.25314>; else goto <D.25315>;
      <D.25314>:
      D.25289 = method->slot;
      D.25298 = D.25289 >> 5;
      D.25299 = (unsigned int) D.25298;
      D.25300 = D.25299 * 4;
      D.25301 = method_slots + D.25300;
      D.25289 = method->slot;
      D.25298 = D.25289 >> 5;
      D.25299 = (unsigned int) D.25298;
      D.25300 = D.25299 * 4;
      D.25301 = method_slots + D.25300;
      D.25302 = *D.25301;
      D.25289 = method->slot;
      D.25303 = (unsigned short) D.25289;
      D.25304 = (int) D.25303;
      D.25305 = D.25304 & 31;
      D.25306 = 1 << D.25305;
      D.25307 = (unsigned int) D.25306;
      D.25316 = D.25302 | D.25307;
      *D.25301 = D.25316;
      <D.25315>:
      <D.25291>:
      if (allow_ctors == 0) goto <D.25319>; else goto <D.25320>;
      <D.25319>:
      D.25321 = method->name;
      D.25322 = *D.25321;
      if (D.25322 == 46) goto <D.25323>; else goto <D.25324>;
      <D.25323>:
      {
        size_t __s1_len;
        size_t __s2_len;

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

          __s2 = method->name;
          D.25328 = ".ctor";
          D.25329 = MEM[(const unsigned char *)D.25328];
          D.25330 = (int) D.25329;
          D.25331 = *__s2;
          D.25332 = (int) D.25331;
          __result = D.25330 - D.25332;
          {
            if (__s2_len != 0) goto <D.25333>; else goto <D.25334>;
            <D.25333>:
            if (__result == 0) goto <D.25335>; else goto <D.25336>;
            <D.25335>:
            D.25337 = &MEM[(void *)".ctor" + 1B];
            D.25338 = *D.25337;
            D.25339 = (int) D.25338;
            D.25340 = __s2 + 1;
            D.25341 = *D.25340;
            D.25342 = (int) D.25341;
            __result = D.25339 - D.25342;
            if (__s2_len > 1) goto <D.25343>; else goto <D.25344>;
            <D.25343>:
            if (__result == 0) goto <D.25345>; else goto <D.25346>;
            <D.25345>:
            D.25347 = &MEM[(void *)".ctor" + 2B];
            D.25348 = *D.25347;
            D.25349 = (int) D.25348;
            D.25350 = __s2 + 2;
            D.25351 = *D.25350;
            D.25352 = (int) D.25351;
            __result = D.25349 - D.25352;
            if (__s2_len > 2) goto <D.25353>; else goto <D.25354>;
            <D.25353>:
            if (__result == 0) goto <D.25355>; else goto <D.25356>;
            <D.25355>:
            D.25357 = &MEM[(void *)".ctor" + 3B];
            D.25358 = *D.25357;
            D.25359 = (int) D.25358;
            D.25360 = __s2 + 3;
            D.25361 = *D.25360;
            D.25362 = (int) D.25361;
            __result = D.25359 - D.25362;
            <D.25356>:
            <D.25354>:
            <D.25346>:
            <D.25344>:
            <D.25336>:
            <D.25334>:
          }
          D.21852 = __result;
        }
        iftmp.4 = -D.21852;
        goto <D.25363>;
        <D.25327>:
        D.25321 = method->name;
        iftmp.4 = __builtin_strcmp (D.25321, ".ctor");
        <D.25363>:
        D.21853 = iftmp.4;
      }
      if (D.21853 == 0) goto <D.25317>; else goto <D.25364>;
      <D.25364>:
      {
        size_t __s1_len;
        size_t __s2_len;

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

          __s2 = method->name;
          D.25368 = ".cctor";
          D.25369 = MEM[(const unsigned char *)D.25368];
          D.25370 = (int) D.25369;
          D.25371 = *__s2;
          D.25372 = (int) D.25371;
          __result = D.25370 - D.25372;
          {
            if (__s2_len != 0) goto <D.25373>; else goto <D.25374>;
            <D.25373>:
            if (__result == 0) goto <D.25375>; else goto <D.25376>;
            <D.25375>:
            D.25377 = &MEM[(void *)".cctor" + 1B];
            D.25378 = *D.25377;
            D.25379 = (int) D.25378;
            D.25380 = __s2 + 1;
            D.25381 = *D.25380;
            D.25382 = (int) D.25381;
            __result = D.25379 - D.25382;
            if (__s2_len > 1) goto <D.25383>; else goto <D.25384>;
            <D.25383>:
            if (__result == 0) goto <D.25385>; else goto <D.25386>;
            <D.25385>:
            D.25387 = &MEM[(void *)".cctor" + 2B];
            D.25388 = *D.25387;
            D.25389 = (int) D.25388;
            D.25390 = __s2 + 2;
            D.25391 = *D.25390;
            D.25392 = (int) D.25391;
            __result = D.25389 - D.25392;
            if (__s2_len > 2) goto <D.25393>; else goto <D.25394>;
            <D.25393>:
            if (__result == 0) goto <D.25395>; else goto <D.25396>;
            <D.25395>:
            D.25397 = &MEM[(void *)".cctor" + 3B];
            D.25398 = *D.25397;
            D.25399 = (int) D.25398;
            D.25400 = __s2 + 3;
            D.25401 = *D.25400;
            D.25402 = (int) D.25401;
            __result = D.25399 - D.25402;
            <D.25396>:
            <D.25394>:
            <D.25386>:
            <D.25384>:
            <D.25376>:
            <D.25374>:
          }
          D.21861 = __result;
        }
        iftmp.5 = -D.21861;
        goto <D.25403>;
        <D.25367>:
        D.25321 = method->name;
        iftmp.5 = __builtin_strcmp (D.25321, ".cctor");
        <D.25403>:
        D.21862 = iftmp.5;
      }
      if (D.21862 == 0) goto <D.25317>; else goto <D.25318>;
      <D.25317>:
      // predicted unlikely by continue predictor.
      goto <D.21844>;
      <D.25318>:
      <D.25324>:
      <D.25320>:
      D.25311 = method->flags;
      D.25312 = (int) D.25311;
      D.25404 = D.25312 & 7;
      if (D.25404 == 6) goto <D.25405>; else goto <D.25406>;
      <D.25405>:
      D.25407 = bflags & 16;
      if (D.25407 != 0) goto <D.25408>; else goto <D.25409>;
      <D.25408>:
      match = match + 1;
      <D.25409>:
      goto <D.25410>;
      <D.25406>:
      D.25411 = bflags & 32;
      if (D.25411 != 0) goto <D.25412>; else goto <D.25413>;
      <D.25412>:
      D.25414 = klass == startklass;
      D.25415 = (int) D.25414;
      D.25416 = method_nonpublic (method, D.25415);
      if (D.25416 != 0) goto <D.25417>; else goto <D.25418>;
      <D.25417>:
      match = match + 1;
      <D.25418>:
      <D.25413>:
      <D.25410>:
      if (match == 0) goto <D.25419>; else goto <D.25420>;
      <D.25419>:
      // predicted unlikely by continue predictor.
      goto <D.21844>;
      <D.25420>:
      match = 0;
      D.25311 = method->flags;
      D.25312 = (int) D.25311;
      D.25421 = D.25312 & 16;
      if (D.25421 != 0) goto <D.25422>; else goto <D.25423>;
      <D.25422>:
      D.25424 = bflags & 8;
      if (D.25424 != 0) goto <D.25425>; else goto <D.25426>;
      <D.25425>:
      D.25429 = bflags & 64;
      if (D.25429 != 0) goto <D.25427>; else goto <D.25430>;
      <D.25430>:
      if (klass == startklass) goto <D.25427>; else goto <D.25428>;
      <D.25427>:
      match = match + 1;
      <D.25428>:
      <D.25426>:
      goto <D.25431>;
      <D.25423>:
      D.25432 = bflags & 4;
      if (D.25432 != 0) goto <D.25433>; else goto <D.25434>;
      <D.25433>:
      match = match + 1;
      <D.25434>:
      <D.25431>:
      if (match == 0) goto <D.25435>; else goto <D.25436>;
      <D.25435>:
      // predicted unlikely by continue predictor.
      goto <D.21844>;
      <D.25436>:
      if (name != 0B) goto <D.25437>; else goto <D.25438>;
      <D.25437>:
      D.25321 = method->name;
      D.25439 = compare_func (name, D.25321);
      if (D.25439 != 0) goto <D.25440>; else goto <D.25441>;
      <D.25440>:
      // predicted unlikely by continue predictor.
      goto <D.21844>;
      <D.25441>:
      <D.25438>:
      match = 0;
      monoeg_g_ptr_array_add (array, method);
      <D.21844>:
      method = mono_class_get_methods (klass, &iter);
      if (method != 0B) goto <D.21863>; else goto <D.21864>;
      <D.21864>:
      D.25442 = bflags & 2;
      if (D.25442 == 0) goto <D.25443>; else goto <D.25444>;
      <D.25443>:
      klass = klass->parent;
      if (klass != 0B) goto handle_parent; else goto <D.25445>;
      <D.25445>:
      <D.25444>:
      if (&method_slots_default != method_slots) goto <D.25446>; else goto <D.25447>;
      <D.25446>:
      monoeg_g_free (method_slots);
      <D.25447>:
      D.25258 = array;
      return D.25258;
      loader_error:
      if (&method_slots_default != method_slots) goto <D.25448>; else goto <D.25449>;
      <D.25448>:
      monoeg_g_free (method_slots);
      <D.25449>:
      monoeg_g_ptr_array_free (array, 1);
      D.25259 = klass->exception_type;
      if (D.25259 != 0) goto <D.25450>; else goto <D.25451>;
      <D.25450>:
      D.25452 = mono_class_get_exception_for_failure (klass);
      *ex = D.25452;
      goto <D.25453>;
      <D.25451>:
      D.25454 = mono_loader_get_last_error ();
      D.25455 = mono_loader_error_prepare_exception (D.25454);
      *ex = D.25455;
      mono_loader_clear_error ();
      <D.25453>:
      D.25258 = 0B;
      return D.25258;
    }
  finally
    {
      iter = {CLOBBER};
      method_slots_default = {CLOBBER};
    }
}


is_generic_parameter (struct MonoType * type)
{
  MonoBoolean D.25458;
  int iftmp.6;
  unsigned int D.25463;
  unsigned int D.25464;
  unsigned char D.25466;

  D.25463 = BIT_FIELD_REF <*type, 32, 32>;
  D.25464 = D.25463 & 1073741824;
  if (D.25464 == 0) goto <D.25465>; else goto <D.25460>;
  <D.25465>:
  D.25466 = type->type;
  if (D.25466 == 19) goto <D.25461>; else goto <D.25467>;
  <D.25467>:
  D.25466 = type->type;
  if (D.25466 == 30) goto <D.25461>; else goto <D.25460>;
  <D.25461>:
  iftmp.6 = 1;
  goto <D.25462>;
  <D.25460>:
  iftmp.6 = 0;
  <D.25462>:
  D.25458 = (MonoBoolean) iftmp.6;
  return D.25458;
}


memset (void * __dest, int __ch, size_t __len)
{
  int D.25471;
  int D.25476;
  void * D.25478;
  unsigned int D.25479;

  D.25471 = __builtin_constant_p (__len);
  if (D.25471 != 0) goto <D.25472>; else goto <D.25473>;
  <D.25472>:
  if (__len == 0) goto <D.25474>; else goto <D.25475>;
  <D.25474>:
  D.25476 = __builtin_constant_p (__ch);
  if (D.25476 == 0) goto <D.25469>; else goto <D.25477>;
  <D.25477>:
  if (__ch != 0) goto <D.25469>; else goto <D.25470>;
  <D.25469>:
  __warn_memset_zero_len ();
  D.25478 = __dest;
  return D.25478;
  <D.25470>:
  <D.25475>:
  <D.25473>:
  D.25479 = __builtin_object_size (__dest, 0);
  D.25478 = __builtin___memset_chk (__dest, __ch, __len, D.25479);
  return D.25478;
}


method_nonpublic (struct MonoMethod * method, gboolean start_klass)
{
  short unsigned int D.25481;
  int D.25482;
  int D.25483;
  gboolean D.25484;
  int iftmp.7;
  struct MonoClass * D.25490;

  D.25481 = method->flags;
  D.25482 = (int) D.25481;
  D.25483 = D.25482 & 7;
  switch (D.25483) <default: <D.21812>, case 1: <D.21810>, case 3: <D.21809>, case 6: <D.21811>>
  <D.21809>:
  if (start_klass != 0) goto <D.25486>; else goto <D.25489>;
  <D.25489>:
  D.25490 = mono_defaults.generic_ilist_class;
  if (D.25490 != 0B) goto <D.25486>; else goto <D.25487>;
  <D.25486>:
  iftmp.7 = 1;
  goto <D.25488>;
  <D.25487>:
  iftmp.7 = 0;
  <D.25488>:
  D.25484 = iftmp.7;
  return D.25484;
  <D.21810>:
  D.25484 = start_klass;
  return D.25484;
  <D.21811>:
  D.25484 = 0;
  return D.25484;
  <D.21812>:
  D.25484 = 1;
  return D.25484;
}


ves_icall_System_Environment_get_UserName ()
{
  struct MonoString * D.25492;
  struct MonoDomain * D.25493;
  const gchar * D.25494;

  D.25493 = mono_domain_get ();
  D.25494 = monoeg_g_get_user_name ();
  D.25492 = mono_string_new (D.25493, D.25494);
  return D.25492;
}


mono_icall_init ()
{
  int D.24894;
  short unsigned int D.25500;
  sizetype D.25501;
  const char * D.25502;
  const struct IcallTypeDesc * D.25505;
  short unsigned int D.25506;
  int D.25507;
  short unsigned int D.25508;
  int D.25509;
  int D.25510;
  short unsigned int D.25511;
  sizetype D.25512;
  int D.24904;
  struct GHashTable * icall_hash.8;
  int i;

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

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

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

        D.25500 = icall_type_names_idx[i];
        D.25501 = (sizetype) D.25500;
        D.25502 = &icall_type_names_str + D.25501;
        D.24894 = __builtin_strcmp (prev_class, D.25502);
      }
      if (D.24894 >= 0) goto <D.25503>; else goto <D.25504>;
      <D.25503>:
      D.25500 = icall_type_names_idx[i];
      D.25501 = (sizetype) D.25500;
      D.25502 = &icall_type_names_str + D.25501;
      monoeg_g_print ("class %s should come before class %s\n", D.25502, prev_class);
      <D.25504>:
      <D.25499>:
      D.25500 = icall_type_names_idx[i];
      D.25501 = (sizetype) D.25500;
      prev_class = &icall_type_names_str + D.25501;
      desc = &icall_type_descs[i];
      D.25505 = desc + 2;
      D.25506 = D.25505->first_icall;
      D.25507 = (int) D.25506;
      D.25508 = desc->first_icall;
      D.25509 = (int) D.25508;
      num_icalls = D.25507 - D.25509;
      j = 0;
      goto <D.24906>;
      <D.24905>:
      {
        const char * methodn;

        D.25508 = desc->first_icall;
        D.25509 = (int) D.25508;
        D.25510 = D.25509 + j;
        D.25511 = icall_names_idx[D.25510];
        D.25512 = (sizetype) D.25511;
        methodn = &icall_names_str + D.25512;
        if (prev_method != 0B) goto <D.25513>; else goto <D.25514>;
        <D.25513>:
        {
          size_t __s1_len;
          size_t __s2_len;

          D.24904 = __builtin_strcmp (prev_method, methodn);
        }
        if (D.24904 >= 0) goto <D.25515>; else goto <D.25516>;
        <D.25515>:
        monoeg_g_print ("method %s should come before method %s\n", methodn, prev_method);
        <D.25516>:
        <D.25514>:
        prev_method = methodn;
      }
      j = j + 1;
      <D.24906>:
      if (j < num_icalls) goto <D.24905>; else goto <D.24907>;
      <D.24907>:
    }
    i = i + 1;
    <D.24909>:
    if (i <= 107) goto <D.24908>; else goto <D.24910>;
    <D.24910>:
  }
  <D.25497>:
  icall_hash.8 = monoeg_g_hash_table_new_full (monoeg_g_str_hash, monoeg_g_str_equal, monoeg_g_free, 0B);
  icall_hash = icall_hash.8;
  pthread_mutex_init (&icall_mutex, 0B);
}


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

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


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

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


mono_icall_lock ()
{
  pthread_mutex_lock (&icall_mutex);
}


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

  if (str != 0B) goto <D.25523>; else goto <D.25524>;
  <D.25523>:
  D.25525 = __strdup (str);
  return D.25525;
  <D.25524>:
  D.25525 = 0B;
  return D.25525;
}


mono_icall_unlock ()
{
  pthread_mutex_unlock (&icall_mutex);
}


mono_lookup_internal_call (struct MonoMethod * method)
{
  _Bool D.25527;
  long int D.25528;
  long int D.25529;
  unsigned int D.25532;
  unsigned int D.25533;
  struct MonoClass * D.25536;
  struct MonoClass * D.25537;
  void * D.25542;
  int pos.13;
  sizetype pos.14;
  char * D.25545;
  unsigned int pos.15;
  unsigned int D.25547;
  int D.25548;
  int D.25554;
  const char * D.25555;
  unsigned int D.25556;
  sizetype typelen.16;
  sizetype D.25558;
  char * D.25559;
  unsigned int mlen.17;
  sizetype mlen.18;
  sizetype D.25562;
  sizetype D.25563;
  struct MonoMethodSignature * D.25564;
  unsigned int D.25565;
  int D.25566;
  int D.25567;
  int D.25568;
  unsigned int D.25569;
  char * D.25572;
  unsigned int siglen.19;
  sizetype siglen.20;
  sizetype D.25575;
  char * D.25576;
  sizetype D.25577;
  char * D.25578;
  struct GHashTable * icall_hash.21;
  sizetype D.25586;
  char * D.25587;
  struct MonoImage * D.25592;
  char * D.25593;
  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.25527 = method == 0B;
      D.25528 = (long int) D.25527;
      D.25529 = __builtin_expect (D.25528, 0);
      if (D.25529 != 0) goto <D.25530>; else goto <D.25531>;
      <D.25530>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "icall.c", 8049, "method != NULL");
      <D.25531>:
      D.25532 = BIT_FIELD_REF <*method, 32, 160>;
      D.25533 = D.25532 & 4096;
      if (D.25533 != 0) goto <D.25534>; else goto <D.25535>;
      <D.25534>:
      method = MEM[(struct MonoMethodInflated *)method].declaring;
      <D.25535>:
      D.25536 = method->klass;
      D.25537 = D.25536->nested_in;
      if (D.25537 != 0B) goto <D.25538>; else goto <D.25539>;
      <D.25538>:
      {
        int pos;

        D.25536 = method->klass;
        D.25537 = D.25536->nested_in;
        pos = concat_class_name (&mname, 2046, D.25537);
        if (pos == 0) goto <D.25540>; else goto <D.25541>;
        <D.25540>:
        D.25542 = 0B;
        return D.25542;
        <D.25541>:
        pos.13 = pos;
        pos = pos.13 + 1;
        mname[pos.13] = 47;
        mname[pos] = 0;
        pos.14 = (sizetype) pos;
        D.25545 = &mname + pos.14;
        pos.15 = (unsigned int) pos;
        D.25547 = 2047 - pos.15;
        D.25548 = (int) D.25547;
        D.25536 = method->klass;
        typelen = concat_class_name (D.25545, D.25548, D.25536);
        if (typelen == 0) goto <D.25549>; else goto <D.25550>;
        <D.25549>:
        D.25542 = 0B;
        return D.25542;
        <D.25550>:
        typelen = typelen + pos;
      }
      goto <D.25551>;
      <D.25539>:
      D.25536 = method->klass;
      typelen = concat_class_name (&mname, 2048, D.25536);
      if (typelen == 0) goto <D.25552>; else goto <D.25553>;
      <D.25552>:
      D.25542 = 0B;
      return D.25542;
      <D.25553>:
      <D.25551>:
      imap = find_class_icalls (&mname);
      mname[typelen] = 58;
      D.25554 = typelen + 1;
      mname[D.25554] = 58;
      D.25555 = method->name;
      D.25556 = strlen (D.25555);
      mlen = (int) D.25556;
      typelen.16 = (sizetype) typelen;
      D.25558 = typelen.16 + 2;
      D.25559 = &mname + D.25558;
      D.25555 = method->name;
      mlen.17 = (unsigned int) mlen;
      memcpy (D.25559, D.25555, mlen.17);
      typelen.16 = (sizetype) typelen;
      mlen.18 = (sizetype) mlen;
      D.25562 = typelen.16 + mlen.18;
      D.25563 = D.25562 + 2;
      sigstart = &mname + D.25563;
      *sigstart = 0;
      D.25564 = mono_method_signature (method);
      tmpsig = mono_signature_get_desc (D.25564, 1);
      D.25565 = strlen (tmpsig);
      siglen = (int) D.25565;
      D.25566 = typelen + mlen;
      D.25567 = D.25566 + siglen;
      D.25568 = D.25567 + 6;
      D.25569 = (unsigned int) D.25568;
      if (D.25569 > 2048) goto <D.25570>; else goto <D.25571>;
      <D.25570>:
      D.25542 = 0B;
      return D.25542;
      <D.25571>:
      *sigstart = 40;
      D.25572 = sigstart + 1;
      siglen.19 = (unsigned int) siglen;
      memcpy (D.25572, tmpsig, siglen.19);
      siglen.20 = (sizetype) siglen;
      D.25575 = siglen.20 + 1;
      D.25576 = sigstart + D.25575;
      *D.25576 = 41;
      siglen.20 = (sizetype) siglen;
      D.25577 = siglen.20 + 2;
      D.25578 = sigstart + D.25577;
      *D.25578 = 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.25580>; else goto <D.25581>;
      <D.25580>:
      mono_icall_unlock ();
      D.25542 = res;
      return D.25542;
      <D.25581>:
      *sigstart = 0;
      icall_hash.21 = icall_hash;
      res = monoeg_g_hash_table_lookup (icall_hash.21, &mname);
      if (res != 0B) goto <D.25582>; else goto <D.25583>;
      <D.25582>:
      mono_icall_unlock ();
      D.25542 = res;
      return D.25542;
      <D.25583>:
      if (imap == 0B) goto <D.25584>; else goto <D.25585>;
      <D.25584>:
      mono_icall_unlock ();
      D.25542 = 0B;
      return D.25542;
      <D.25585>:
      mlen.18 = (sizetype) mlen;
      D.25586 = -mlen.18;
      D.25587 = sigstart + D.25586;
      res = find_method_icall (imap, D.25587);
      if (res != 0B) goto <D.25588>; else goto <D.25589>;
      <D.25588>:
      mono_icall_unlock ();
      D.25542 = res;
      return D.25542;
      <D.25589>:
      *sigstart = 40;
      mlen.18 = (sizetype) mlen;
      D.25586 = -mlen.18;
      D.25587 = sigstart + D.25586;
      res = find_method_icall (imap, D.25587);
      if (res != 0B) goto <D.25590>; else goto <D.25591>;
      <D.25590>:
      mono_icall_unlock ();
      D.25542 = res;
      return D.25542;
      <D.25591>:
      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.25536 = method->klass;
      D.25592 = D.25536->image;
      D.25593 = D.25592->name;
      monoeg_g_print ("The out of sync library is: %s\n", D.25593);
      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.25542 = 0B;
      return D.25542;
    }
  finally
    {
      mname = {CLOBBER};
    }
}


concat_class_name (char * buf, int bufsize, struct MonoClass * klass)
{
  const char * D.25596;
  unsigned int D.25597;
  const char * D.25598;
  unsigned int D.25599;
  int D.25600;
  int D.25601;
  int D.25604;
  unsigned int nspacelen.22;
  int nspacelen.23;
  sizetype nspacelen.24;
  char * D.25610;
  sizetype nspacelen.25;
  char * D.25612;
  unsigned int cnamelen.26;
  sizetype D.25614;
  char * D.25615;
  int nspacelen;
  int cnamelen;

  D.25596 = klass->name_space;
  D.25597 = strlen (D.25596);
  nspacelen = (int) D.25597;
  D.25598 = klass->name;
  D.25599 = strlen (D.25598);
  cnamelen = (int) D.25599;
  D.25600 = nspacelen + cnamelen;
  D.25601 = D.25600 + 1;
  if (D.25601 >= bufsize) goto <D.25602>; else goto <D.25603>;
  <D.25602>:
  D.25604 = 0;
  return D.25604;
  <D.25603>:
  if (nspacelen != 0) goto <D.25605>; else goto <D.25606>;
  <D.25605>:
  D.25596 = klass->name_space;
  nspacelen.22 = (unsigned int) nspacelen;
  memcpy (buf, D.25596, nspacelen.22);
  nspacelen.23 = nspacelen;
  nspacelen = nspacelen.23 + 1;
  nspacelen.24 = (sizetype) nspacelen.23;
  D.25610 = buf + nspacelen.24;
  *D.25610 = 46;
  <D.25606>:
  nspacelen.25 = (sizetype) nspacelen;
  D.25612 = buf + nspacelen.25;
  D.25598 = klass->name;
  cnamelen.26 = (unsigned int) cnamelen;
  memcpy (D.25612, D.25598, cnamelen.26);
  D.25600 = nspacelen + cnamelen;
  D.25614 = (sizetype) D.25600;
  D.25615 = buf + D.25614;
  *D.25615 = 0;
  D.25604 = nspacelen + cnamelen;
  return D.25604;
}


find_class_icalls (const char * name)
{
  const struct IcallTypeDesc * D.25619;
  int nameslot.27;
  int D.25621;
  int D.25622;
  int D.25623;
  const guint16 * nameslot;

  nameslot = mono_binary_search (name, &icall_type_names_idx, 108, 2, compare_class_imap);
  if (nameslot == 0B) goto <D.25617>; else goto <D.25618>;
  <D.25617>:
  D.25619 = 0B;
  return D.25619;
  <D.25618>:
  nameslot.27 = (int) nameslot;
  D.25621 = (int) &icall_type_names_idx[0];
  D.25622 = nameslot.27 - D.25621;
  D.25623 = D.25622 /[ex] 2;
  D.25619 = &icall_type_descs[D.25623];
  return D.25619;
}


compare_class_imap (const void * key, const void * elem)
{
  short unsigned int D.25625;
  sizetype D.25626;
  int D.25627;
  int D.24956;
  const char * class_name;

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

    D.24956 = __builtin_strcmp (key, class_name);
  }
  D.25627 = D.24956;
  return D.25627;
}


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

  D.25630 = __builtin_object_size (__dest, 0);
  D.25629 = __builtin___memcpy_chk (__dest, __src, __len, D.25630);
  return D.25629;
}


find_method_icall (const struct IcallTypeDesc * imap, const char * name)
{
  short unsigned int D.25632;
  unsigned int D.25633;
  unsigned int D.25634;
  const void * D.25635;
  const struct IcallTypeDesc * D.25636;
  short unsigned int D.25637;
  int D.25638;
  int D.25639;
  int D.25640;
  unsigned int D.25641;
  void * D.25644;
  int nameslot.28;
  int D.25646;
  int D.25647;
  int D.25648;
  const guint16 * nameslot;

  D.25632 = imap->first_icall;
  D.25633 = (unsigned int) D.25632;
  D.25634 = D.25633 * 2;
  D.25635 = &icall_names_idx + D.25634;
  D.25636 = imap + 2;
  D.25637 = D.25636->first_icall;
  D.25638 = (int) D.25637;
  D.25632 = imap->first_icall;
  D.25639 = (int) D.25632;
  D.25640 = D.25638 - D.25639;
  D.25641 = (unsigned int) D.25640;
  nameslot = mono_binary_search (name, D.25635, D.25641, 2, compare_method_imap);
  if (nameslot == 0B) goto <D.25642>; else goto <D.25643>;
  <D.25642>:
  D.25644 = 0B;
  return D.25644;
  <D.25643>:
  nameslot.28 = (int) nameslot;
  D.25646 = (int) &icall_names_idx[0];
  D.25647 = nameslot.28 - D.25646;
  D.25648 = D.25647 /[ex] 2;
  D.25644 = icall_functions[D.25648];
  return D.25644;
}


ves_icall_get_resources_ptr (struct MonoReflectionAssembly * assembly, void * * result, gint32 * size)
{
  gboolean D.25654;
  struct MonoAssembly * D.25655;
  unsigned int D.25658;
  char * D.25659;
  void * D.25660;
  unsigned int D.25663;
  int D.25664;
  struct MonoPEResourceDataEntry * entry;
  struct MonoImage * image;

  if (assembly == 0B) goto <D.25650>; else goto <D.25652>;
  <D.25652>:
  if (result == 0B) goto <D.25650>; else goto <D.25653>;
  <D.25653>:
  if (size == 0B) goto <D.25650>; else goto <D.25651>;
  <D.25650>:
  D.25654 = 0;
  return D.25654;
  <D.25651>:
  *result = 0B;
  *size = 0;
  D.25655 = assembly->assembly;
  image = D.25655->image;
  entry = mono_image_lookup_resource (image, 101, 0, 0B);
  if (entry == 0B) goto <D.25656>; else goto <D.25657>;
  <D.25656>:
  D.25654 = 0;
  return D.25654;
  <D.25657>:
  D.25658 = entry->rde_data_offset;
  D.25659 = mono_image_rva_map (image, D.25658);
  *result = D.25659;
  D.25660 = *result;
  if (D.25660 == 0B) goto <D.25661>; else goto <D.25662>;
  <D.25661>:
  monoeg_g_free (entry);
  D.25654 = 0;
  return D.25654;
  <D.25662>:
  D.25663 = entry->rde_size;
  D.25664 = (int) D.25663;
  *size = D.25664;
  monoeg_g_free (entry);
  D.25654 = 1;
  return D.25654;
}


ves_icall_System_Web_Util_ICalls_get_machine_install_dir ()
{
  const char * D.25666;
  struct MonoDomain * D.25667;
  struct MonoString * D.25668;
  struct MonoString * ipath;
  gchar * path;

  D.25666 = mono_get_config_dir ();
  path = monoeg_g_path_get_dirname (D.25666);
  D.25667 = mono_domain_get ();
  ipath = mono_string_new (D.25667, path);
  monoeg_g_free (path);
  D.25668 = ipath;
  return D.25668;
}


ves_icall_System_ValueType_InternalGetHashCode (struct MonoObject * this, struct MonoArray * * fields)
{
  struct MonoVTable * D.25670;
  int D.25671;
  gint32 D.25674;
  struct MonoType * D.25675;
  short unsigned int D.25676;
  int D.25677;
  int D.25678;
  int D.25681;
  int D.20704;
  int iftmp.29;
  int D.20703;
  const char[9] * D.25687;
  unsigned char D.25688;
  int D.25689;
  unsigned char D.25690;
  int D.25691;
  const unsigned char * D.25696;
  unsigned char D.25697;
  int D.25698;
  const unsigned char * D.25699;
  unsigned char D.25700;
  int D.25701;
  const unsigned char * D.25706;
  unsigned char D.25707;
  int D.25708;
  const unsigned char * D.25709;
  unsigned char D.25710;
  int D.25711;
  const unsigned char * D.25716;
  unsigned char D.25717;
  int D.25718;
  const unsigned char * D.25719;
  unsigned char D.25720;
  int D.25721;
  const char * D.25723;
  unsigned char D.25726;
  int D.25727;
  int D.25728;
  sizetype D.25729;
  gint32 * D.25730;
  int D.25731;
  struct MonoString * * D.25732;
  unsigned int D.25735;
  unsigned int result.30;
  unsigned int D.25737;
  int D.25740;
  unsigned int D.25741;
  unsigned int D.25742;
  struct MonoDomain * D.25743;
  int count.31;
  unsigned int count.32;
  unsigned int D.25746;
  struct MonoObject * * D.25747;
  struct MonoDomain * D.25750;
  struct MonoClass * D.25751;
  unsigned int count.33;
  struct MonoArray * D.25753;
  struct MonoArray * D.25754;
  unsigned int i.34;
  unsigned int i.35;
  unsigned int D.25757;
  struct MonoObject * * D.25758;
  struct MonoObject * D.25759;
  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.25670 = this->vtable;
      klass = D.25670->klass;
      D.25671 = mono_class_num_fields (klass);
      if (D.25671 == 0) goto <D.25672>; else goto <D.25673>;
      <D.25672>:
      D.25674 = mono_object_hash (this);
      return D.25674;
      <D.25673>:
      iter = 0B;
      goto <D.20695>;
      <D.20710>:
      D.25675 = field->type;
      D.25676 = D.25675->attrs;
      D.25677 = (int) D.25676;
      D.25678 = D.25677 & 16;
      if (D.25678 != 0) goto <D.25679>; else goto <D.25680>;
      <D.25679>:
      // predicted unlikely by continue predictor.
      goto <D.20695>;
      <D.25680>:
      D.25675 = field->type;
      D.25676 = D.25675->attrs;
      D.25677 = (int) D.25676;
      D.25681 = D.25677 & 1536;
      if (D.25681 != 0) goto <D.25682>; else goto <D.25683>;
      <D.25682>:
      {
        size_t __s1_len;
        size_t __s2_len;

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

          __s2 = mono_field_get_name (field);
          D.25687 = "_Deleted";
          D.25688 = MEM[(const unsigned char *)D.25687];
          D.25689 = (int) D.25688;
          D.25690 = *__s2;
          D.25691 = (int) D.25690;
          __result = D.25689 - D.25691;
          {
            if (__s2_len != 0) goto <D.25692>; else goto <D.25693>;
            <D.25692>:
            if (__result == 0) goto <D.25694>; else goto <D.25695>;
            <D.25694>:
            D.25696 = &MEM[(void *)"_Deleted" + 1B];
            D.25697 = *D.25696;
            D.25698 = (int) D.25697;
            D.25699 = __s2 + 1;
            D.25700 = *D.25699;
            D.25701 = (int) D.25700;
            __result = D.25698 - D.25701;
            if (__s2_len > 1) goto <D.25702>; else goto <D.25703>;
            <D.25702>:
            if (__result == 0) goto <D.25704>; else goto <D.25705>;
            <D.25704>:
            D.25706 = &MEM[(void *)"_Deleted" + 2B];
            D.25707 = *D.25706;
            D.25708 = (int) D.25707;
            D.25709 = __s2 + 2;
            D.25710 = *D.25709;
            D.25711 = (int) D.25710;
            __result = D.25708 - D.25711;
            if (__s2_len > 2) goto <D.25712>; else goto <D.25713>;
            <D.25712>:
            if (__result == 0) goto <D.25714>; else goto <D.25715>;
            <D.25714>:
            D.25716 = &MEM[(void *)"_Deleted" + 3B];
            D.25717 = *D.25716;
            D.25718 = (int) D.25717;
            D.25719 = __s2 + 3;
            D.25720 = *D.25719;
            D.25721 = (int) D.25720;
            __result = D.25718 - D.25721;
            <D.25715>:
            <D.25713>:
            <D.25705>:
            <D.25703>:
            <D.25695>:
            <D.25693>:
          }
          D.20703 = __result;
        }
        iftmp.29 = -D.20703;
        goto <D.25722>;
        <D.25686>:
        D.25723 = mono_field_get_name (field);
        iftmp.29 = __builtin_strcmp (D.25723, "_Deleted");
        <D.25722>:
        D.20704 = iftmp.29;
      }
      if (D.20704 == 0) goto <D.25724>; else goto <D.25725>;
      <D.25724>:
      // predicted unlikely by continue predictor.
      goto <D.20695>;
      <D.25725>:
      <D.25683>:
      D.25675 = field->type;
      D.25726 = D.25675->type;
      D.25727 = (int) D.25726;
      switch (D.25727) <default: <D.20709>, case 8: <D.20705>, case 14: <D.20707>>
      <D.20705>:
      D.25728 = field->offset;
      D.25729 = (sizetype) D.25728;
      D.25730 = this + D.25729;
      D.25731 = *D.25730;
      result = D.25731 ^ result;
      goto <D.20706>;
      <D.20707>:
      {
        struct MonoString * s;

        D.25728 = field->offset;
        D.25729 = (sizetype) D.25728;
        D.25732 = this + D.25729;
        s = *D.25732;
        if (s != 0B) goto <D.25733>; else goto <D.25734>;
        <D.25733>:
        D.25735 = mono_string_hash (s);
        result.30 = (unsigned int) result;
        D.25737 = D.25735 ^ result.30;
        result = (gint32) D.25737;
        <D.25734>:
        goto <D.20706>;
      }
      <D.20709>:
      if (values == 0B) goto <D.25738>; else goto <D.25739>;
      <D.25738>:
      D.25740 = mono_class_num_fields (klass);
      D.25741 = (unsigned int) D.25740;
      D.25742 = D.25741 * 4;
      values = __builtin_alloca (D.25742);
      <D.25739>:
      D.25670 = this->vtable;
      D.25743 = D.25670->domain;
      o = mono_field_get_value_object (D.25743, field, this);
      count.31 = count;
      count = count.31 + 1;
      count.32 = (unsigned int) count.31;
      D.25746 = count.32 * 4;
      D.25747 = values + D.25746;
      *D.25747 = o;
      <D.20706>:
      <D.20695>:
      field = mono_class_get_fields (klass, &iter);
      if (field != 0B) goto <D.20710>; else goto <D.20711>;
      <D.20711>:
      if (values != 0B) goto <D.25748>; else goto <D.25749>;
      <D.25748>:
      {
        int i;

        D.25750 = mono_domain_get ();
        D.25751 = mono_defaults.object_class;
        count.33 = (unsigned int) count;
        D.25753 = mono_array_new (D.25750, D.25751, count.33);
        mono_gc_wbarrier_generic_store (fields, D.25753);
        i = 0;
        goto <D.20715>;
        <D.20714>:
        {
          void * * __p;

          D.25754 = *fields;
          i.34 = (unsigned int) i;
          __p = mono_array_addr_with_size (D.25754, 4, i.34);
          D.25754 = *fields;
          i.35 = (unsigned int) i;
          D.25757 = i.35 * 4;
          D.25758 = values + D.25757;
          D.25759 = *D.25758;
          mono_gc_wbarrier_set_arrayref (D.25754, __p, D.25759);
        }
        i = i + 1;
        <D.20715>:
        if (i < count) goto <D.20714>; else goto <D.20716>;
        <D.20716>:
      }
      goto <D.25760>;
      <D.25749>:
      *fields = 0B;
      <D.25760>:
      D.25674 = result;
      return D.25674;
    }
  finally
    {
      iter = {CLOBBER};
    }
}


ves_icall_System_ValueType_Equals (struct MonoObject * this, struct MonoObject * that, struct MonoArray * * fields)
{
  _Bool D.25763;
  long int D.25764;
  long int D.25765;
  struct MonoVTable * D.25770;
  struct MonoVTable * D.25771;
  MonoBoolean D.25774;
  unsigned int D.25775;
  unsigned int D.25776;
  struct MonoType * D.25779;
  struct MonoType * D.25782;
  unsigned char D.25783;
  gint32 * D.25786;
  int D.25787;
  gint32 * D.25788;
  int D.25789;
  _Bool D.25790;
  struct MonoType * D.25791;
  short unsigned int D.25792;
  int D.25793;
  int D.25794;
  int D.25797;
  int D.20738;
  int iftmp.36;
  int D.20737;
  const char[9] * D.25803;
  unsigned char D.25804;
  int D.25805;
  unsigned char D.25806;
  int D.25807;
  const unsigned char * D.25812;
  unsigned char D.25813;
  int D.25814;
  const unsigned char * D.25815;
  unsigned char D.25816;
  int D.25817;
  const unsigned char * D.25822;
  unsigned char D.25823;
  int D.25824;
  const unsigned char * D.25825;
  unsigned char D.25826;
  int D.25827;
  const unsigned char * D.25832;
  unsigned char D.25833;
  int D.25834;
  const unsigned char * D.25835;
  unsigned char D.25836;
  int D.25837;
  const char * D.25839;
  unsigned char D.25842;
  int D.25843;
  int D.25844;
  sizetype D.25845;
  guint8 * D.25846;
  unsigned char D.25847;
  guint8 * D.25848;
  unsigned char D.25849;
  gint16 * D.25852;
  short int D.25853;
  gint16 * D.25854;
  short int D.25855;
  gint32 * D.25858;
  int D.25859;
  gint32 * D.25860;
  int D.25861;
  gint64 * D.25864;
  long long int D.25865;
  gint64 * D.25866;
  long long int D.25867;
  float * D.25870;
  float D.25871;
  float * D.25872;
  float D.25873;
  double * D.25876;
  double D.25877;
  double * D.25878;
  double D.25879;
  struct MonoString * * D.25882;
  struct MonoString * * D.25883;
  int D.25888;
  int D.25889;
  mono_unichar2 * D.25892;
  mono_unichar2 * D.25893;
  unsigned int D.25894;
  int D.25895;
  int D.25900;
  unsigned int D.25901;
  unsigned int D.25902;
  struct MonoDomain * D.25903;
  int count.37;
  unsigned int count.38;
  unsigned int D.25906;
  struct MonoObject * * D.25907;
  int count.39;
  unsigned int count.40;
  unsigned int D.25910;
  struct MonoObject * * D.25911;
  struct MonoDomain * D.25915;
  struct MonoClass * D.25916;
  unsigned int count.41;
  struct MonoArray * D.25918;
  struct MonoArray * D.25919;
  double[0:] * D.25920;
  unsigned int i.42;
  unsigned int D.25922;
  struct MonoObject * * D.25923;
  struct MonoObject * D.25924;
  struct MonoClass * klass;
  struct MonoObject * * values;
  struct MonoObject * o;
  struct MonoClassField * field;
  void * iter;
  int count;

  try
    {
      values = 0B;
      count = 0;
      D.25763 = that == 0B;
      D.25764 = (long int) D.25763;
      D.25765 = __builtin_expect (D.25764, 0);
      if (D.25765 != 0) goto <D.25766>; else goto <D.25767>;
      <D.25766>:
      {
        struct MonoException * ex;

        if (that != 0B) goto <D.25768>; else goto <D.25769>;
        <D.25768>:
        <D.25769>:
        ex = mono_get_exception_argument_null ("that");
        mono_raise_exception (ex);
      }
      <D.25767>:
      D.25770 = this->vtable;
      D.25771 = that->vtable;
      if (D.25770 != D.25771) goto <D.25772>; else goto <D.25773>;
      <D.25772>:
      D.25774 = 0;
      return D.25774;
      <D.25773>:
      D.25770 = this->vtable;
      klass = D.25770->klass;
      D.25775 = BIT_FIELD_REF <*klass, 32, 160>;
      D.25776 = D.25775 & 16;
      if (D.25776 != 0) goto <D.25777>; else goto <D.25778>;
      <D.25777>:
      D.25779 = mono_class_enum_basetype (klass);
      if (D.25779 != 0B) goto <D.25780>; else goto <D.25781>;
      <D.25780>:
      D.25782 = mono_class_enum_basetype (klass);
      D.25783 = D.25782->type;
      if (D.25783 == 8) goto <D.25784>; else goto <D.25785>;
      <D.25784>:
      D.25786 = this + 8;
      D.25787 = *D.25786;
      D.25788 = that + 8;
      D.25789 = *D.25788;
      D.25790 = D.25787 == D.25789;
      D.25774 = (MonoBoolean) D.25790;
      return D.25774;
      <D.25785>:
      <D.25781>:
      <D.25778>:
      *fields = 0B;
      iter = 0B;
      goto <D.20729>;
      <D.20759>:
      D.25791 = field->type;
      D.25792 = D.25791->attrs;
      D.25793 = (int) D.25792;
      D.25794 = D.25793 & 16;
      if (D.25794 != 0) goto <D.25795>; else goto <D.25796>;
      <D.25795>:
      // predicted unlikely by continue predictor.
      goto <D.20729>;
      <D.25796>:
      D.25791 = field->type;
      D.25792 = D.25791->attrs;
      D.25793 = (int) D.25792;
      D.25797 = D.25793 & 1536;
      if (D.25797 != 0) goto <D.25798>; else goto <D.25799>;
      <D.25798>:
      {
        size_t __s1_len;
        size_t __s2_len;

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

          __s2 = mono_field_get_name (field);
          D.25803 = "_Deleted";
          D.25804 = MEM[(const unsigned char *)D.25803];
          D.25805 = (int) D.25804;
          D.25806 = *__s2;
          D.25807 = (int) D.25806;
          __result = D.25805 - D.25807;
          {
            if (__s2_len != 0) goto <D.25808>; else goto <D.25809>;
            <D.25808>:
            if (__result == 0) goto <D.25810>; else goto <D.25811>;
            <D.25810>:
            D.25812 = &MEM[(void *)"_Deleted" + 1B];
            D.25813 = *D.25812;
            D.25814 = (int) D.25813;
            D.25815 = __s2 + 1;
            D.25816 = *D.25815;
            D.25817 = (int) D.25816;
            __result = D.25814 - D.25817;
            if (__s2_len > 1) goto <D.25818>; else goto <D.25819>;
            <D.25818>:
            if (__result == 0) goto <D.25820>; else goto <D.25821>;
            <D.25820>:
            D.25822 = &MEM[(void *)"_Deleted" + 2B];
            D.25823 = *D.25822;
            D.25824 = (int) D.25823;
            D.25825 = __s2 + 2;
            D.25826 = *D.25825;
            D.25827 = (int) D.25826;
            __result = D.25824 - D.25827;
            if (__s2_len > 2) goto <D.25828>; else goto <D.25829>;
            <D.25828>:
            if (__result == 0) goto <D.25830>; else goto <D.25831>;
            <D.25830>:
            D.25832 = &MEM[(void *)"_Deleted" + 3B];
            D.25833 = *D.25832;
            D.25834 = (int) D.25833;
            D.25835 = __s2 + 3;
            D.25836 = *D.25835;
            D.25837 = (int) D.25836;
            __result = D.25834 - D.25837;
            <D.25831>:
            <D.25829>:
            <D.25821>:
            <D.25819>:
            <D.25811>:
            <D.25809>:
          }
          D.20737 = __result;
        }
        iftmp.36 = -D.20737;
        goto <D.25838>;
        <D.25802>:
        D.25839 = mono_field_get_name (field);
        iftmp.36 = __builtin_strcmp (D.25839, "_Deleted");
        <D.25838>:
        D.20738 = iftmp.36;
      }
      if (D.20738 == 0) goto <D.25840>; else goto <D.25841>;
      <D.25840>:
      // predicted unlikely by continue predictor.
      goto <D.20729>;
      <D.25841>:
      <D.25799>:
      D.25791 = field->type;
      D.25842 = D.25791->type;
      D.25843 = (int) D.25842;
      switch (D.25843) <default: <D.20757>, case 2: <D.20741>, case 3: <D.20745>, case 4: <D.20740>, case 5: <D.20739>, case 6: <D.20744>, case 7: <D.20743>, case 8: <D.20747>, case 9: <D.20746>, case 10: <D.20749>, case 11: <D.20748>, case 12: <D.20750>, case 13: <D.20751>, case 14: <D.20752>>
      <D.20739>:
      <D.20740>:
      <D.20741>:
      D.25844 = field->offset;
      D.25845 = (sizetype) D.25844;
      D.25846 = this + D.25845;
      D.25847 = *D.25846;
      D.25844 = field->offset;
      D.25845 = (sizetype) D.25844;
      D.25848 = that + D.25845;
      D.25849 = *D.25848;
      if (D.25847 != D.25849) goto <D.25850>; else goto <D.25851>;
      <D.25850>:
      D.25774 = 0;
      return D.25774;
      <D.25851>:
      goto <D.20742>;
      <D.20743>:
      <D.20744>:
      <D.20745>:
      D.25844 = field->offset;
      D.25845 = (sizetype) D.25844;
      D.25852 = this + D.25845;
      D.25853 = *D.25852;
      D.25844 = field->offset;
      D.25845 = (sizetype) D.25844;
      D.25854 = that + D.25845;
      D.25855 = *D.25854;
      if (D.25853 != D.25855) goto <D.25856>; else goto <D.25857>;
      <D.25856>:
      D.25774 = 0;
      return D.25774;
      <D.25857>:
      goto <D.20742>;
      <D.20746>:
      <D.20747>:
      D.25844 = field->offset;
      D.25845 = (sizetype) D.25844;
      D.25858 = this + D.25845;
      D.25859 = *D.25858;
      D.25844 = field->offset;
      D.25845 = (sizetype) D.25844;
      D.25860 = that + D.25845;
      D.25861 = *D.25860;
      if (D.25859 != D.25861) goto <D.25862>; else goto <D.25863>;
      <D.25862>:
      D.25774 = 0;
      return D.25774;
      <D.25863>:
      goto <D.20742>;
      <D.20748>:
      <D.20749>:
      D.25844 = field->offset;
      D.25845 = (sizetype) D.25844;
      D.25864 = this + D.25845;
      D.25865 = *D.25864;
      D.25844 = field->offset;
      D.25845 = (sizetype) D.25844;
      D.25866 = that + D.25845;
      D.25867 = *D.25866;
      if (D.25865 != D.25867) goto <D.25868>; else goto <D.25869>;
      <D.25868>:
      D.25774 = 0;
      return D.25774;
      <D.25869>:
      goto <D.20742>;
      <D.20750>:
      D.25844 = field->offset;
      D.25845 = (sizetype) D.25844;
      D.25870 = this + D.25845;
      D.25871 = *D.25870;
      D.25844 = field->offset;
      D.25845 = (sizetype) D.25844;
      D.25872 = that + D.25845;
      D.25873 = *D.25872;
      if (D.25871 != D.25873) goto <D.25874>; else goto <D.25875>;
      <D.25874>:
      D.25774 = 0;
      return D.25774;
      <D.25875>:
      goto <D.20742>;
      <D.20751>:
      D.25844 = field->offset;
      D.25845 = (sizetype) D.25844;
      D.25876 = this + D.25845;
      D.25877 = *D.25876;
      D.25844 = field->offset;
      D.25845 = (sizetype) D.25844;
      D.25878 = that + D.25845;
      D.25879 = *D.25878;
      if (D.25877 != D.25879) goto <D.25880>; else goto <D.25881>;
      <D.25880>:
      D.25774 = 0;
      return D.25774;
      <D.25881>:
      goto <D.20742>;
      <D.20752>:
      {
        struct MonoString * s1;
        struct MonoString * s2;
        guint32 s1len;
        guint32 s2len;

        D.25844 = field->offset;
        D.25845 = (sizetype) D.25844;
        D.25882 = this + D.25845;
        s1 = *D.25882;
        D.25844 = field->offset;
        D.25845 = (sizetype) D.25844;
        D.25883 = that + D.25845;
        s2 = *D.25883;
        if (s1 == s2) goto <D.20742>; else goto <D.25884>;
        <D.25884>:
        if (s1 == 0B) goto <D.25885>; else goto <D.25887>;
        <D.25887>:
        if (s2 == 0B) goto <D.25885>; else goto <D.25886>;
        <D.25885>:
        D.25774 = 0;
        return D.25774;
        <D.25886>:
        D.25888 = mono_string_length (s1);
        s1len = (guint32) D.25888;
        D.25889 = mono_string_length (s2);
        s2len = (guint32) D.25889;
        if (s1len != s2len) goto <D.25890>; else goto <D.25891>;
        <D.25890>:
        D.25774 = 0;
        return D.25774;
        <D.25891>:
        D.25892 = mono_string_chars (s1);
        D.25893 = mono_string_chars (s2);
        D.25894 = s1len * 2;
        D.25895 = memcmp (D.25892, D.25893, D.25894);
        if (D.25895 != 0) goto <D.25896>; else goto <D.25897>;
        <D.25896>:
        D.25774 = 0;
        return D.25774;
        <D.25897>:
        goto <D.20742>;
      }
      <D.20757>:
      if (values == 0B) goto <D.25898>; else goto <D.25899>;
      <D.25898>:
      D.25900 = mono_class_num_fields (klass);
      D.25901 = (unsigned int) D.25900;
      D.25902 = D.25901 * 8;
      values = __builtin_alloca (D.25902);
      <D.25899>:
      D.25770 = this->vtable;
      D.25903 = D.25770->domain;
      o = mono_field_get_value_object (D.25903, field, this);
      count.37 = count;
      count = count.37 + 1;
      count.38 = (unsigned int) count.37;
      D.25906 = count.38 * 4;
      D.25907 = values + D.25906;
      *D.25907 = o;
      D.25770 = this->vtable;
      D.25903 = D.25770->domain;
      o = mono_field_get_value_object (D.25903, field, that);
      count.39 = count;
      count = count.39 + 1;
      count.40 = (unsigned int) count.39;
      D.25910 = count.40 * 4;
      D.25911 = values + D.25910;
      *D.25911 = o;
      <D.20742>:
      D.25775 = BIT_FIELD_REF <*klass, 32, 160>;
      D.25776 = D.25775 & 16;
      if (D.25776 != 0) goto <D.20758>; else goto <D.25912>;
      <D.25912>:
      <D.20729>:
      field = mono_class_get_fields (klass, &iter);
      if (field != 0B) goto <D.20759>; else goto <D.20758>;
      <D.20758>:
      if (values != 0B) goto <D.25913>; else goto <D.25914>;
      <D.25913>:
      {
        int i;

        D.25915 = mono_domain_get ();
        D.25916 = mono_defaults.object_class;
        count.41 = (unsigned int) count;
        D.25918 = mono_array_new (D.25915, D.25916, count.41);
        mono_gc_wbarrier_generic_store (fields, D.25918);
        i = 0;
        goto <D.20763>;
        <D.20762>:
        {
          void * * __p;

          D.25919 = *fields;
          D.25920 = &D.25919->vector;
          i.42 = (unsigned int) i;
          D.25922 = i.42 * 4;
          __p = D.25920 + D.25922;
          D.25919 = *fields;
          i.42 = (unsigned int) i;
          D.25922 = i.42 * 4;
          D.25923 = values + D.25922;
          D.25924 = *D.25923;
          mono_gc_wbarrier_set_arrayref (D.25919, __p, D.25924);
        }
        i = i + 1;
        <D.20763>:
        if (i < count) goto <D.20762>; else goto <D.20764>;
        <D.20764>:
        D.25774 = 0;
        return D.25774;
      }
      <D.25914>:
      D.25774 = 1;
      return D.25774;
    }
  finally
    {
      iter = {CLOBBER};
    }
}


mono_TypedReference_ToObjectInternal (struct MonoType * type, void * value, struct MonoClass * klass)
{
  int D.25927;
  struct MonoObject * D.25930;
  struct MonoDomain * D.25931;

  D.25927 = mono_type_is_reference (type);
  if (D.25927 != 0) goto <D.25928>; else goto <D.25929>;
  <D.25928>:
  {
    struct MonoObject * * objp;

    objp = value;
    D.25930 = *objp;
    return D.25930;
  }
  <D.25929>:
  D.25931 = mono_domain_get ();
  D.25930 = mono_value_box (D.25931, klass, value);
  return D.25930;
}


mono_TypedReference_ToObject (struct MonoTypedRef tref)
{
  struct MonoType * D.25933;
  int D.25934;
  struct MonoObject * D.25937;
  struct MonoDomain * D.25938;
  struct MonoClass * D.25939;
  void * D.25940;

  D.25933 = tref.type;
  D.25934 = mono_type_is_reference (D.25933);
  if (D.25934 != 0) goto <D.25935>; else goto <D.25936>;
  <D.25935>:
  {
    struct MonoObject * * objp;

    objp = tref.value;
    D.25937 = *objp;
    return D.25937;
  }
  <D.25936>:
  D.25938 = mono_domain_get ();
  D.25939 = tref.klass;
  D.25940 = tref.value;
  D.25937 = mono_value_box (D.25938, D.25939, D.25940);
  return D.25937;
}


ves_icall_type_is_subtype_of (struct MonoReflectionType * type, struct MonoReflectionType * c, MonoBoolean check_interfaces)
{
  _Bool D.25942;
  long int D.25943;
  long int D.25944;
  struct MonoVTable * D.25947;
  guint32 D.25950;
  struct MonoType * D.25951;
  struct MonoType * D.25952;
  struct MonoClass * * D.25958;
  struct MonoClass * * D.25960;
  unsigned int D.25961;
  unsigned int D.25962;
  struct MonoClass * D.25965;
  _Bool D.25966;
  int D.25967;
  int D.25968;
  struct MonoDomain * domain;
  struct MonoClass * klass;
  struct MonoClass * klassc;

  D.25942 = type == 0B;
  D.25943 = (long int) D.25942;
  D.25944 = __builtin_expect (D.25943, 0);
  if (D.25944 != 0) goto <D.25945>; else goto <D.25946>;
  <D.25945>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "icall.c", 1502, "type != NULL");
  <D.25946>:
  D.25947 = MEM[(struct MonoObject *)type].vtable;
  domain = D.25947->domain;
  if (c == 0B) goto <D.25948>; else goto <D.25949>;
  <D.25948>:
  D.25950 = 0;
  return D.25950;
  <D.25949>:
  D.25951 = type->type;
  klass = mono_class_from_mono_type (D.25951);
  D.25952 = c->type;
  klassc = mono_class_from_mono_type (D.25952);
  if (check_interfaces != 0) goto <D.25953>; else goto <D.25954>;
  <D.25953>:
  mono_class_init_or_throw (klass);
  mono_class_init_or_throw (klassc);
  goto <D.25955>;
  <D.25954>:
  D.25958 = klass->supertypes;
  if (D.25958 == 0B) goto <D.25956>; else goto <D.25959>;
  <D.25959>:
  D.25960 = klassc->supertypes;
  if (D.25960 == 0B) goto <D.25956>; else goto <D.25957>;
  <D.25956>:
  mono_class_setup_supertypes (klass);
  mono_class_setup_supertypes (klassc);
  <D.25957>:
  <D.25955>:
  D.25951 = type->type;
  D.25961 = BIT_FIELD_REF <*D.25951, 32, 32>;
  D.25962 = D.25961 & 1073741824;
  if (D.25962 != 0) goto <D.25963>; else goto <D.25964>;
  <D.25963>:
  D.25965 = mono_defaults.object_class;
  D.25966 = D.25965 == klassc;
  D.25950 = (guint32) D.25966;
  return D.25950;
  <D.25964>:
  D.25967 = (int) check_interfaces;
  D.25968 = mono_class_is_subclass_of (klass, klassc, D.25967);
  D.25950 = (guint32) D.25968;
  return D.25950;
}


mono_class_init_or_throw (struct MonoClass * klass)
{
  int D.25970;
  struct MonoException * D.25973;

  D.25970 = mono_class_init (klass);
  if (D.25970 == 0) goto <D.25971>; else goto <D.25972>;
  <D.25971>:
  D.25973 = mono_class_get_exception_for_failure (klass);
  mono_raise_exception (D.25973);
  <D.25972>:
}


ves_icall_type_is_assignable_from (struct MonoReflectionType * type, struct MonoReflectionType * c)
{
  _Bool D.25974;
  long int D.25975;
  long int D.25976;
  struct MonoVTable * D.25979;
  struct MonoType * D.25980;
  struct MonoType * D.25981;
  unsigned int D.25982;
  unsigned int D.25983;
  unsigned int D.25984;
  unsigned int D.25985;
  guint32 D.25988;
  unsigned int D.25989;
  int D.25992;
  int iftmp.43;
  int D.25998;
  int D.26000;
  int D.26001;
  unsigned char D.26005;
  int iftmp.44;
  unsigned char D.26010;
  struct MonoGenericParam * D.26012;
  short unsigned int D.26013;
  struct MonoGenericParam * D.26014;
  short unsigned int D.26015;
  _Bool D.26020;
  unsigned int D.26024;
  unsigned int D.26025;
  _Bool D.26028;
  unsigned int D.26029;
  unsigned int D.26030;
  unsigned int D.26031;
  _Bool D.26032;
  int D.26033;
  struct MonoDomain * domain;
  struct MonoClass * klass;
  struct MonoClass * klassc;

  D.25974 = type == 0B;
  D.25975 = (long int) D.25974;
  D.25976 = __builtin_expect (D.25975, 0);
  if (D.25976 != 0) goto <D.25977>; else goto <D.25978>;
  <D.25977>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "icall.c", 1555, "type != NULL");
  <D.25978>:
  D.25979 = MEM[(struct MonoObject *)type].vtable;
  domain = D.25979->domain;
  D.25980 = type->type;
  klass = mono_class_from_mono_type (D.25980);
  D.25981 = c->type;
  klassc = mono_class_from_mono_type (D.25981);
  D.25980 = type->type;
  D.25982 = BIT_FIELD_REF <*D.25980, 32, 32>;
  D.25981 = c->type;
  D.25983 = BIT_FIELD_REF <*D.25981, 32, 32>;
  D.25984 = D.25982 ^ D.25983;
  D.25985 = D.25984 & 1073741824;
  if (D.25985 != 0) goto <D.25986>; else goto <D.25987>;
  <D.25986>:
  D.25988 = 0;
  return D.25988;
  <D.25987>:
  D.25980 = type->type;
  D.25982 = BIT_FIELD_REF <*D.25980, 32, 32>;
  D.25989 = D.25982 & 1073741824;
  if (D.25989 != 0) goto <D.25990>; else goto <D.25991>;
  <D.25990>:
  {
    struct MonoType * t;
    struct MonoType * ot;

    D.25980 = type->type;
    t = mono_type_get_underlying_type_ignore_byref (D.25980);
    D.25981 = c->type;
    ot = mono_type_get_underlying_type_ignore_byref (D.25981);
    klass = mono_class_from_mono_type (t);
    klassc = mono_class_from_mono_type (ot);
    D.25992 = mono_type_is_primitive (t);
    if (D.25992 != 0) goto <D.25993>; else goto <D.25994>;
    <D.25993>:
    D.25998 = mono_type_is_primitive (ot);
    if (D.25998 != 0) goto <D.25999>; else goto <D.25996>;
    <D.25999>:
    D.26000 = klass->instance_size;
    D.26001 = klassc->instance_size;
    if (D.26000 == D.26001) goto <D.26002>; else goto <D.25996>;
    <D.26002>:
    iftmp.43 = 1;
    goto <D.25997>;
    <D.25996>:
    iftmp.43 = 0;
    <D.25997>:
    D.25988 = (guint32) iftmp.43;
    return D.25988;
    <D.25994>:
    D.26005 = t->type;
    if (D.26005 == 19) goto <D.26003>; else goto <D.26006>;
    <D.26006>:
    D.26005 = t->type;
    if (D.26005 == 30) goto <D.26003>; else goto <D.26004>;
    <D.26003>:
    D.26005 = t->type;
    D.26010 = ot->type;
    if (D.26005 == D.26010) goto <D.26011>; else goto <D.26008>;
    <D.26011>:
    D.26012 = t->data.generic_param;
    D.26013 = D.26012->num;
    D.26014 = ot->data.generic_param;
    D.26015 = D.26014->num;
    if (D.26013 == D.26015) goto <D.26016>; else goto <D.26008>;
    <D.26016>:
    iftmp.44 = 1;
    goto <D.26009>;
    <D.26008>:
    iftmp.44 = 0;
    <D.26009>:
    D.25988 = (guint32) iftmp.44;
    return D.25988;
    <D.26004>:
    D.26005 = t->type;
    if (D.26005 == 15) goto <D.26017>; else goto <D.26019>;
    <D.26019>:
    D.26005 = t->type;
    if (D.26005 == 27) goto <D.26017>; else goto <D.26018>;
    <D.26017>:
    D.26005 = t->type;
    D.26010 = ot->type;
    D.26020 = D.26005 == D.26010;
    D.25988 = (guint32) D.26020;
    return D.25988;
    <D.26018>:
    D.26010 = ot->type;
    if (D.26010 == 19) goto <D.26021>; else goto <D.26023>;
    <D.26023>:
    D.26010 = ot->type;
    if (D.26010 == 30) goto <D.26021>; else goto <D.26022>;
    <D.26021>:
    D.25988 = 0;
    return D.25988;
    <D.26022>:
    D.26024 = BIT_FIELD_REF <*klass, 32, 160>;
    D.26025 = D.26024 & 8;
    if (D.26025 != 0) goto <D.26026>; else goto <D.26027>;
    <D.26026>:
    D.26028 = klass == klassc;
    D.25988 = (guint32) D.26028;
    return D.25988;
    <D.26027>:
    D.26024 = BIT_FIELD_REF <*klass, 32, 160>;
    D.26029 = BIT_FIELD_REF <*klassc, 32, 160>;
    D.26030 = D.26024 ^ D.26029;
    D.26031 = D.26030 & 8;
    D.26032 = D.26031 == 0;
    D.25988 = (guint32) D.26032;
    return D.25988;
  }
  <D.25991>:
  D.26033 = mono_class_is_assignable_from (klass, klassc);
  D.25988 = (guint32) D.26033;
  return D.25988;
}


mono_type_get_underlying_type_ignore_byref (struct MonoType * type)
{
  unsigned char D.26035;
  struct MonoClass * D.26038;
  unsigned int D.26039;
  unsigned int D.26040;
  struct MonoType * D.26043;
  struct MonoGenericClass * D.26046;
  struct MonoClass * D.26047;
  unsigned int D.26048;
  unsigned int D.26049;

  D.26035 = type->type;
  if (D.26035 == 17) goto <D.26036>; else goto <D.26037>;
  <D.26036>:
  D.26038 = type->data.klass;
  D.26039 = BIT_FIELD_REF <*D.26038, 32, 160>;
  D.26040 = D.26039 & 16;
  if (D.26040 != 0) goto <D.26041>; else goto <D.26042>;
  <D.26041>:
  D.26038 = type->data.klass;
  D.26043 = mono_class_enum_basetype (D.26038);
  return D.26043;
  <D.26042>:
  <D.26037>:
  D.26035 = type->type;
  if (D.26035 == 21) goto <D.26044>; else goto <D.26045>;
  <D.26044>:
  D.26046 = type->data.generic_class;
  D.26047 = D.26046->container_class;
  D.26048 = BIT_FIELD_REF <*D.26047, 32, 160>;
  D.26049 = D.26048 & 16;
  if (D.26049 != 0) goto <D.26050>; else goto <D.26051>;
  <D.26050>:
  D.26046 = type->data.generic_class;
  D.26047 = D.26046->container_class;
  D.26043 = mono_class_enum_basetype (D.26047);
  return D.26043;
  <D.26051>:
  <D.26045>:
  D.26043 = type;
  return D.26043;
}


mono_type_is_primitive (struct MonoType * type)
{
  gboolean D.26053;
  int iftmp.45;
  unsigned char D.26058;
  unsigned char D.26059;

  D.26058 = type->type;
  D.26059 = D.26058 + 254;
  if (D.26059 <= 11) goto <D.26055>; else goto <D.26060>;
  <D.26060>:
  D.26058 = type->type;
  if (D.26058 == 24) goto <D.26055>; else goto <D.26061>;
  <D.26061>:
  D.26058 = type->type;
  if (D.26058 == 25) goto <D.26055>; else goto <D.26056>;
  <D.26055>:
  iftmp.45 = 1;
  goto <D.26057>;
  <D.26056>:
  iftmp.45 = 0;
  <D.26057>:
  D.26053 = iftmp.45;
  return D.26053;
}


ves_icall_Type_make_byref_type (struct MonoReflectionType * type)
{
  struct MonoType * D.26063;
  struct MonoReflectionType * D.26064;
  struct MonoVTable * D.26065;
  struct MonoDomain * D.26066;
  struct MonoType * D.26067;
  struct MonoClass * klass;

  D.26063 = type->type;
  klass = mono_class_from_mono_type (D.26063);
  mono_class_init_or_throw (klass);
  check_for_invalid_type (klass);
  D.26065 = MEM[(struct MonoObject *)type].vtable;
  D.26066 = D.26065->domain;
  D.26067 = &klass->this_arg;
  D.26064 = mono_type_get_object (D.26066, D.26067);
  return D.26064;
}


check_for_invalid_type (struct MonoClass * klass)
{
  unsigned char D.26069;
  struct MonoDomain * D.26072;
  struct MonoException * D.26073;
  char * name;
  struct MonoString * str;

  D.26069 = klass->byval_arg.type;
  if (D.26069 != 22) goto <D.26070>; else goto <D.26071>;
  <D.26070>:
  return;
  <D.26071>:
  name = mono_type_get_full_name (klass);
  D.26072 = mono_domain_get ();
  str = mono_string_new (D.26072, name);
  monoeg_g_free (name);
  D.26073 = mono_get_exception_type_load (str, 0B);
  mono_raise_exception (D.26073);
}


ves_icall_Type_make_array_type (struct MonoReflectionType * type, int rank)
{
  struct MonoType * D.26075;
  unsigned int rank.46;
  struct MonoReflectionType * D.26080;
  struct MonoVTable * D.26081;
  struct MonoDomain * D.26082;
  struct MonoType * D.26083;
  struct MonoClass * klass;
  struct MonoClass * aklass;

  D.26075 = type->type;
  klass = mono_class_from_mono_type (D.26075);
  check_for_invalid_type (klass);
  if (rank == 0) goto <D.26076>; else goto <D.26077>;
  <D.26076>:
  aklass = mono_array_class_get (klass, 1);
  goto <D.26078>;
  <D.26077>:
  rank.46 = (unsigned int) rank;
  aklass = mono_bounded_array_class_get (klass, rank.46, 1);
  <D.26078>:
  D.26081 = MEM[(struct MonoObject *)type].vtable;
  D.26082 = D.26081->domain;
  D.26083 = &aklass->byval_arg;
  D.26080 = mono_type_get_object (D.26082, D.26083);
  return D.26080;
}


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

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

    e = 0B;
    if (throwOnError != 0) goto <D.26088>; else goto <D.26089>;
    <D.26088>:
    e = mono_get_exception_type_load (name, 0B);
    <D.26089>:
    mono_loader_clear_error ();
    if (e != 0B) goto <D.26090>; else goto <D.26091>;
    <D.26090>:
    mono_raise_exception (e);
    <D.26091>:
  }
  <D.26087>:
  D.26092 = type;
  return D.26092;
}


type_from_name (const char * str, MonoBoolean ignoreCase)
{
  int D.26094;
  struct MonoReflectionType * D.26097;
  const char * D.26098;
  struct MonoMethod * dest.47;
  struct MonoClass * D.26107;
  struct MonoImage * D.26108;
  struct MonoImage * D.26112;
  int D.26113;
  int type_resolve.48;
  struct MonoDomain * D.26127;
  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.26094 = mono_reflection_parse_type (temp_str, &info);
      if (D.26094 == 0) goto <D.26095>; else goto <D.26096>;
      <D.26095>:
      mono_reflection_free_type_info (&info);
      monoeg_g_free (temp_str);
      D.26097 = 0B;
      return D.26097;
      <D.26096>:
      D.26098 = info.assembly.name;
      if (D.26098 != 0B) goto <D.26099>; else goto <D.26100>;
      <D.26099>:
      assembly = mono_assembly_load (&info.assembly, 0B, 0B);
      goto <D.26101>;
      <D.26100>:
      {
        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.26103>; else goto <D.26104>;
            <D.26103>:
            dest = m;
            <D.26104>:
            dest.47 = dest;
            if (dest.47 != 0B) goto <D.26105>; else goto <D.26106>;
            <D.26105>:
            dest.47 = dest;
            D.26107 = dest.47->klass;
            D.26108 = D.26107->image;
            assembly = D.26108->assembly;
            type_resolve = 1;
            goto <D.26109>;
            <D.26106>:
            monoeg_g_log (0B, 16, "icall.c:1303:");
            <D.26109>:
          }
        finally
          {
            dest = {CLOBBER};
          }
      }
      <D.26101>:
      if (assembly != 0B) goto <D.26110>; else goto <D.26111>;
      <D.26110>:
      D.26112 = assembly->image;
      D.26113 = (int) ignoreCase;
      type = mono_reflection_get_type (D.26112, &info, D.26113, &type_resolve);
      <D.26111>:
      D.26098 = info.assembly.name;
      if (D.26098 == 0B) goto <D.26114>; else goto <D.26115>;
      <D.26114>:
      if (type == 0B) goto <D.26116>; else goto <D.26117>;
      <D.26116>:
      D.26113 = (int) ignoreCase;
      type = mono_reflection_get_type (0B, &info, D.26113, &type_resolve);
      <D.26117>:
      <D.26115>:
      if (assembly != 0B) goto <D.26118>; else goto <D.26119>;
      <D.26118>:
      if (type == 0B) goto <D.26120>; else goto <D.26121>;
      <D.26120>:
      type_resolve.48 = type_resolve;
      if (type_resolve.48 != 0) goto <D.26123>; else goto <D.26124>;
      <D.26123>:
      type_resolve = 0;
      D.26112 = assembly->image;
      D.26113 = (int) ignoreCase;
      type = mono_reflection_get_type (D.26112, &info, D.26113, &type_resolve);
      <D.26124>:
      <D.26121>:
      <D.26119>:
      mono_reflection_free_type_info (&info);
      monoeg_g_free (temp_str);
      if (type == 0B) goto <D.26125>; else goto <D.26126>;
      <D.26125>:
      D.26097 = 0B;
      return D.26097;
      <D.26126>:
      D.26127 = mono_domain_get ();
      D.26097 = mono_type_get_object (D.26127, type);
      return D.26097;
    }
  finally
    {
      info = {CLOBBER};
      type_resolve = {CLOBBER};
    }
}


get_caller_no_reflection (struct MonoMethod * m, gint32 no, gint32 ilo, gboolean managed, void * data)
{
  gboolean D.26132;
  unsigned int D.26133;
  unsigned int D.26134;
  struct MonoClass * D.26137;
  struct MonoImage * D.26138;
  struct MonoImage * D.26139;
  int D.20837;
  int iftmp.49;
  int D.20836;
  const char[18] * D.26145;
  unsigned char D.26146;
  int D.26147;
  unsigned char D.26148;
  int D.26149;
  const unsigned char * D.26154;
  unsigned char D.26155;
  int D.26156;
  const unsigned char * D.26157;
  unsigned char D.26158;
  int D.26159;
  const unsigned char * D.26164;
  unsigned char D.26165;
  int D.26166;
  const unsigned char * D.26167;
  unsigned char D.26168;
  int D.26169;
  const unsigned char * D.26174;
  unsigned char D.26175;
  int D.26176;
  const unsigned char * D.26177;
  unsigned char D.26178;
  int D.26179;
  const char * D.26181;
  struct MonoMethod * D.26184;
  struct MonoMethod * * dest;

  dest = data;
  if (managed == 0) goto <D.26130>; else goto <D.26131>;
  <D.26130>:
  D.26132 = 0;
  return D.26132;
  <D.26131>:
  D.26133 = BIT_FIELD_REF <*m, 32, 160>;
  D.26134 = D.26133 & 124;
  if (D.26134 != 0) goto <D.26135>; else goto <D.26136>;
  <D.26135>:
  D.26132 = 0;
  return D.26132;
  <D.26136>:
  D.26137 = m->klass;
  D.26138 = D.26137->image;
  D.26139 = mono_defaults.corlib;
  if (D.26138 == D.26139) goto <D.26140>; else goto <D.26141>;
  <D.26140>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      D.26137 = m->klass;
      __s2 = D.26137->name_space;
      D.26145 = "System.Reflection";
      D.26146 = MEM[(const unsigned char *)D.26145];
      D.26147 = (int) D.26146;
      D.26148 = *__s2;
      D.26149 = (int) D.26148;
      __result = D.26147 - D.26149;
      {
        if (__s2_len != 0) goto <D.26150>; else goto <D.26151>;
        <D.26150>:
        if (__result == 0) goto <D.26152>; else goto <D.26153>;
        <D.26152>:
        D.26154 = &MEM[(void *)"System.Reflection" + 1B];
        D.26155 = *D.26154;
        D.26156 = (int) D.26155;
        D.26157 = __s2 + 1;
        D.26158 = *D.26157;
        D.26159 = (int) D.26158;
        __result = D.26156 - D.26159;
        if (__s2_len > 1) goto <D.26160>; else goto <D.26161>;
        <D.26160>:
        if (__result == 0) goto <D.26162>; else goto <D.26163>;
        <D.26162>:
        D.26164 = &MEM[(void *)"System.Reflection" + 2B];
        D.26165 = *D.26164;
        D.26166 = (int) D.26165;
        D.26167 = __s2 + 2;
        D.26168 = *D.26167;
        D.26169 = (int) D.26168;
        __result = D.26166 - D.26169;
        if (__s2_len > 2) goto <D.26170>; else goto <D.26171>;
        <D.26170>:
        if (__result == 0) goto <D.26172>; else goto <D.26173>;
        <D.26172>:
        D.26174 = &MEM[(void *)"System.Reflection" + 3B];
        D.26175 = *D.26174;
        D.26176 = (int) D.26175;
        D.26177 = __s2 + 3;
        D.26178 = *D.26177;
        D.26179 = (int) D.26178;
        __result = D.26176 - D.26179;
        <D.26173>:
        <D.26171>:
        <D.26163>:
        <D.26161>:
        <D.26153>:
        <D.26151>:
      }
      D.20836 = __result;
    }
    iftmp.49 = -D.20836;
    goto <D.26180>;
    <D.26144>:
    D.26137 = m->klass;
    D.26181 = D.26137->name_space;
    iftmp.49 = __builtin_strcmp (D.26181, "System.Reflection");
    <D.26180>:
    D.20837 = iftmp.49;
  }
  if (D.20837 == 0) goto <D.26182>; else goto <D.26183>;
  <D.26182>:
  D.26132 = 0;
  return D.26132;
  <D.26183>:
  <D.26141>:
  D.26184 = *dest;
  if (D.26184 == m) goto <D.26185>; else goto <D.26186>;
  <D.26185>:
  *dest = 0B;
  D.26132 = 0;
  return D.26132;
  <D.26186>:
  D.26184 = *dest;
  if (D.26184 == 0B) goto <D.26187>; else goto <D.26188>;
  <D.26187>:
  *dest = m;
  D.26132 = 1;
  return D.26132;
  <D.26188>:
  D.26132 = 0;
  return D.26132;
}


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

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


ves_icall_Type_get_IsGenericTypeDefinition (struct MonoReflectionType * type)
{
  struct MonoVTable * D.26196;
  struct MonoClass * D.26197;
  struct MonoImage * D.26198;
  struct MonoImage * D.26199;
  struct MonoType * D.26201;
  gboolean D.26202;
  unsigned int D.26203;
  unsigned int D.26204;
  struct MonoGenericContainer * D.26207;
  _Bool D.26208;
  struct MonoClass * klass;

  if (type != 0B) goto <D.26194>; else goto <D.26195>;
  <D.26194>:
  D.26196 = MEM[(struct MonoObject *)type].vtable;
  D.26197 = D.26196->klass;
  D.26198 = D.26197->image;
  D.26199 = mono_defaults.corlib;
  if (D.26198 != D.26199) goto <D.26192>; else goto <D.26200>;
  <D.26200>:
  D.26201 = type->type;
  if (D.26201 == 0B) goto <D.26192>; else goto <D.26193>;
  <D.26192>:
  D.26202 = 0;
  return D.26202;
  <D.26193>:
  <D.26195>:
  D.26201 = type->type;
  D.26203 = BIT_FIELD_REF <*D.26201, 32, 32>;
  D.26204 = D.26203 & 1073741824;
  if (D.26204 != 0) goto <D.26205>; else goto <D.26206>;
  <D.26205>:
  D.26202 = 0;
  return D.26202;
  <D.26206>:
  D.26201 = type->type;
  klass = mono_class_from_mono_type (D.26201);
  D.26207 = klass->generic_container;
  D.26208 = D.26207 != 0B;
  D.26202 = (gboolean) D.26208;
  return D.26202;
}


ves_icall_Type_get_IsGenericType (struct MonoReflectionType * type)
{
  struct MonoVTable * D.26214;
  struct MonoClass * D.26215;
  struct MonoImage * D.26216;
  struct MonoImage * D.26217;
  struct MonoType * D.26219;
  gboolean D.26220;
  unsigned int D.26221;
  unsigned int D.26222;
  int iftmp.50;
  struct MonoGenericClass * D.26229;
  struct MonoGenericContainer * D.26231;
  struct MonoClass * klass;

  if (type != 0B) goto <D.26212>; else goto <D.26213>;
  <D.26212>:
  D.26214 = MEM[(struct MonoObject *)type].vtable;
  D.26215 = D.26214->klass;
  D.26216 = D.26215->image;
  D.26217 = mono_defaults.corlib;
  if (D.26216 != D.26217) goto <D.26210>; else goto <D.26218>;
  <D.26218>:
  D.26219 = type->type;
  if (D.26219 == 0B) goto <D.26210>; else goto <D.26211>;
  <D.26210>:
  D.26220 = 0;
  return D.26220;
  <D.26211>:
  <D.26213>:
  D.26219 = type->type;
  D.26221 = BIT_FIELD_REF <*D.26219, 32, 32>;
  D.26222 = D.26221 & 1073741824;
  if (D.26222 != 0) goto <D.26223>; else goto <D.26224>;
  <D.26223>:
  D.26220 = 0;
  return D.26220;
  <D.26224>:
  D.26219 = type->type;
  klass = mono_class_from_mono_type (D.26219);
  D.26229 = klass->generic_class;
  if (D.26229 != 0B) goto <D.26226>; else goto <D.26230>;
  <D.26230>:
  D.26231 = klass->generic_container;
  if (D.26231 != 0B) goto <D.26226>; else goto <D.26227>;
  <D.26226>:
  iftmp.50 = 1;
  goto <D.26228>;
  <D.26227>:
  iftmp.50 = 0;
  <D.26228>:
  D.26220 = iftmp.50;
  return D.26220;
}


ves_icall_Type_get_IsGenericInstance (struct MonoReflectionType * type)
{
  struct MonoType * D.26233;
  unsigned int D.26234;
  unsigned int D.26235;
  gboolean D.26238;
  struct MonoGenericClass * D.26239;
  _Bool D.26240;
  struct MonoClass * klass;

  D.26233 = type->type;
  D.26234 = BIT_FIELD_REF <*D.26233, 32, 32>;
  D.26235 = D.26234 & 1073741824;
  if (D.26235 != 0) goto <D.26236>; else goto <D.26237>;
  <D.26236>:
  D.26238 = 0;
  return D.26238;
  <D.26237>:
  D.26233 = type->type;
  klass = mono_class_from_mono_type (D.26233);
  D.26239 = klass->generic_class;
  D.26240 = D.26239 != 0B;
  D.26238 = (gboolean) D.26240;
  return D.26238;
}


ves_icall_Type_MakePointerType (struct MonoReflectionType * type)
{
  struct MonoType * D.26242;
  struct MonoReflectionType * D.26243;
  struct MonoVTable * D.26244;
  struct MonoDomain * D.26245;
  struct MonoType * D.26246;
  struct MonoClass * klass;
  struct MonoClass * pklass;

  D.26242 = type->type;
  klass = mono_class_from_mono_type (D.26242);
  mono_class_init_or_throw (klass);
  check_for_invalid_type (klass);
  D.26242 = type->type;
  pklass = mono_ptr_class_get (D.26242);
  D.26244 = MEM[(struct MonoObject *)type].vtable;
  D.26245 = D.26244->domain;
  D.26246 = &pklass->byval_arg;
  D.26243 = mono_type_get_object (D.26245, D.26246);
  return D.26243;
}


ves_icall_Type_MakeGenericType (struct MonoReflectionType * type, struct MonoArray * type_array)
{
  int iftmp.51;
  struct MonoVTable * D.26253;
  struct MonoClass * D.26254;
  struct MonoImage * D.26255;
  struct MonoImage * D.26256;
  struct MonoType * D.26258;
  _Bool D.26259;
  long int D.26260;
  long int D.26261;
  struct MonoClass * D.26264;
  unsigned int D.26265;
  unsigned int count.52;
  unsigned int D.26267;
  unsigned int i.53;
  char * D.26269;
  unsigned int i.54;
  unsigned int D.26271;
  struct MonoType * * D.26272;
  struct MonoType * D.26273;
  struct MonoReflectionType * D.26276;
  struct MonoGenericClass * D.26277;
  int D.26280;
  struct MonoException * D.26283;
  struct MonoDomain * D.26284;
  struct MonoClass * class;
  struct MonoType * geninst;
  struct MonoType * * types;
  int i;
  int count;

  if (type != 0B) goto <D.26252>; else goto <D.26249>;
  <D.26252>:
  D.26253 = MEM[(struct MonoObject *)type].vtable;
  D.26254 = D.26253->klass;
  D.26255 = D.26254->image;
  D.26256 = mono_defaults.corlib;
  if (D.26255 != D.26256) goto <D.26250>; else goto <D.26257>;
  <D.26257>:
  D.26258 = type->type;
  if (D.26258 == 0B) goto <D.26250>; else goto <D.26249>;
  <D.26250>:
  iftmp.51 = 1;
  goto <D.26251>;
  <D.26249>:
  iftmp.51 = 0;
  <D.26251>:
  D.26259 = iftmp.51 != 0;
  D.26260 = (long int) D.26259;
  D.26261 = __builtin_expect (D.26260, 0);
  if (D.26261 != 0) goto <D.26262>; else goto <D.26263>;
  <D.26262>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "icall.c", 2404, "IS_MONOTYPE (type)");
  <D.26263>:
  D.26258 = type->type;
  D.26264 = mono_class_from_mono_type (D.26258);
  mono_class_init_or_throw (D.26264);
  D.26265 = mono_array_length (type_array);
  count = (int) D.26265;
  count.52 = (unsigned int) count;
  D.26267 = count.52 * 4;
  types = monoeg_malloc0 (D.26267);
  i = 0;
  goto <D.21338>;
  <D.21337>:
  {
    struct MonoReflectionType * t;

    i.53 = (unsigned int) i;
    D.26269 = mono_array_addr_with_size (type_array, 4, i.53);
    t = MEM[(void * *)D.26269];
    i.54 = (unsigned int) i;
    D.26271 = i.54 * 4;
    D.26272 = types + D.26271;
    D.26273 = t->type;
    *D.26272 = D.26273;
  }
  i = i + 1;
  <D.21338>:
  if (i < count) goto <D.21337>; else goto <D.21339>;
  <D.21339>:
  geninst = mono_reflection_bind_generic_parameters (type, count, types);
  monoeg_g_free (types);
  if (geninst == 0B) goto <D.26274>; else goto <D.26275>;
  <D.26274>:
  D.26276 = 0B;
  return D.26276;
  <D.26275>:
  class = mono_class_from_mono_type (geninst);
  D.26277 = class->generic_class;
  if (D.26277 != 0B) goto <D.26278>; else goto <D.26279>;
  <D.26278>:
  D.26280 = mono_verifier_class_is_valid_generic_instantiation (class);
  if (D.26280 == 0) goto <D.26281>; else goto <D.26282>;
  <D.26281>:
  D.26283 = mono_get_exception_argument ("typeArguments", "Invalid generic arguments");
  mono_raise_exception (D.26283);
  <D.26282>:
  <D.26279>:
  D.26253 = MEM[(struct MonoObject *)type].vtable;
  D.26284 = D.26253->domain;
  D.26276 = mono_type_get_object (D.26284, geninst);
  return D.26276;
}


ves_icall_type_IsInstanceOfType (struct MonoReflectionType * type, struct MonoObject * obj)
{
  struct MonoType * D.26286;
  guint32 D.26287;
  struct MonoObject * D.26288;
  _Bool D.26289;
  struct MonoClass * klass;

  D.26286 = type->type;
  klass = mono_class_from_mono_type (D.26286);
  mono_class_init_or_throw (klass);
  D.26288 = mono_object_isinst (obj, klass);
  D.26289 = D.26288 != 0B;
  D.26287 = (guint32) D.26289;
  return D.26287;
}


ves_icall_Type_IsArrayImpl (struct MonoReflectionType * t)
{
  int iftmp.55;
  unsigned int D.26295;
  unsigned int D.26296;
  unsigned char D.26298;
  MonoBoolean D.26300;
  struct MonoType * type;
  MonoBoolean res;

  type = t->type;
  D.26295 = BIT_FIELD_REF <*type, 32, 32>;
  D.26296 = D.26295 & 1073741824;
  if (D.26296 == 0) goto <D.26297>; else goto <D.26292>;
  <D.26297>:
  D.26298 = type->type;
  if (D.26298 == 20) goto <D.26293>; else goto <D.26299>;
  <D.26299>:
  D.26298 = type->type;
  if (D.26298 == 29) goto <D.26293>; else goto <D.26292>;
  <D.26293>:
  iftmp.55 = 1;
  goto <D.26294>;
  <D.26292>:
  iftmp.55 = 0;
  <D.26294>:
  res = (MonoBoolean) iftmp.55;
  D.26300 = res;
  return D.26300;
}


ves_icall_type_GetTypeCodeInternal (struct MonoReflectionType * type)
{
  struct MonoType * D.26302;
  unsigned char D.26303;
  unsigned int D.26304;
  unsigned int D.26305;
  guint32 D.26308;
  unsigned int D.26309;
  unsigned int D.26310;
  struct MonoType * D.26313;
  unsigned char D.26314;
  struct MonoImage * D.26315;
  int D.26316;
  int D.20916;
  int iftmp.56;
  int D.20915;
  const char[7] * D.26322;
  unsigned char D.26323;
  int D.26324;
  unsigned char D.26325;
  int D.26326;
  const unsigned char * D.26331;
  unsigned char D.26332;
  int D.26333;
  const unsigned char * D.26334;
  unsigned char D.26335;
  int D.26336;
  const unsigned char * D.26341;
  unsigned char D.26342;
  int D.26343;
  const unsigned char * D.26344;
  unsigned char D.26345;
  int D.26346;
  const unsigned char * D.26351;
  unsigned char D.26352;
  int D.26353;
  const unsigned char * D.26354;
  unsigned char D.26355;
  int D.26356;
  const char * D.26358;
  int D.20925;
  int iftmp.57;
  int D.20924;
  const char[8] * D.26364;
  unsigned char D.26365;
  int D.26366;
  unsigned char D.26367;
  int D.26368;
  const unsigned char * D.26373;
  unsigned char D.26374;
  int D.26375;
  const unsigned char * D.26376;
  unsigned char D.26377;
  int D.26378;
  const unsigned char * D.26383;
  unsigned char D.26384;
  int D.26385;
  const unsigned char * D.26386;
  unsigned char D.26387;
  int D.26388;
  const unsigned char * D.26393;
  unsigned char D.26394;
  int D.26395;
  const unsigned char * D.26396;
  unsigned char D.26397;
  int D.26398;
  const char * D.26400;
  int D.20934;
  int iftmp.58;
  int D.20933;
  const char[9] * D.26406;
  unsigned char D.26407;
  int D.26408;
  unsigned char D.26409;
  int D.26410;
  const unsigned char * D.26415;
  unsigned char D.26416;
  int D.26417;
  const unsigned char * D.26418;
  unsigned char D.26419;
  int D.26420;
  const unsigned char * D.26425;
  unsigned char D.26426;
  int D.26427;
  const unsigned char * D.26428;
  unsigned char D.26429;
  int D.26430;
  const unsigned char * D.26435;
  unsigned char D.26436;
  int D.26437;
  const unsigned char * D.26438;
  unsigned char D.26439;
  int D.26440;
  struct MonoImage * D.26444;
  struct MonoImage * D.26445;
  int D.20952;
  int iftmp.59;
  int D.20951;
  unsigned char D.26451;
  int D.26452;
  const unsigned char * D.26457;
  unsigned char D.26458;
  int D.26459;
  const unsigned char * D.26464;
  unsigned char D.26465;
  int D.26466;
  const unsigned char * D.26471;
  unsigned char D.26472;
  int D.26473;
  const char * D.26475;
  int D.20961;
  int iftmp.60;
  int D.20960;
  const char[7] * D.26481;
  unsigned char D.26482;
  int D.26483;
  unsigned char D.26484;
  int D.26485;
  const unsigned char * D.26490;
  unsigned char D.26491;
  int D.26492;
  const unsigned char * D.26493;
  unsigned char D.26494;
  int D.26495;
  const unsigned char * D.26500;
  unsigned char D.26501;
  int D.26502;
  const unsigned char * D.26503;
  unsigned char D.26504;
  int D.26505;
  const unsigned char * D.26510;
  unsigned char D.26511;
  int D.26512;
  const unsigned char * D.26513;
  unsigned char D.26514;
  int D.26515;
  const char * D.26517;
  int t;
  void handle_enum = <<< error >>>;

  D.26302 = type->type;
  D.26303 = D.26302->type;
  t = (int) D.26303;
  D.26302 = type->type;
  D.26304 = BIT_FIELD_REF <*D.26302, 32, 32>;
  D.26305 = D.26304 & 1073741824;
  if (D.26305 != 0) goto <D.26306>; else goto <D.26307>;
  <D.26306>:
  D.26308 = 1;
  return D.26308;
  <D.26307>:
  handle_enum:
  switch (t) <default: <D.20963>, case 1: <D.20890>, case 2: <D.20891>, case 3: <D.20896>, case 4: <D.20893>, case 5: <D.20892>, case 6: <D.20895>, case 7: <D.20894>, case 8: <D.20901>, case 9: <D.20900>, case 10: <D.20903>, case 11: <D.20902>, case 12: <D.20904>, case 13: <D.20905>, case 14: <D.20935>, case 15: <D.20897>, case 17: <D.20906>, case 18: <D.20942>, case 19: <D.20939>, case 20: <D.20937>, case 21: <D.20962>, case 22: <D.20941>, case 24: <D.20899>, case 25: <D.20898>, case 28: <D.20938>, case 29: <D.20936>, case 30: <D.20940>>
  <D.20890>:
  D.26308 = 1;
  return D.26308;
  <D.20891>:
  D.26308 = 3;
  return D.26308;
  <D.20892>:
  D.26308 = 6;
  return D.26308;
  <D.20893>:
  D.26308 = 5;
  return D.26308;
  <D.20894>:
  D.26308 = 8;
  return D.26308;
  <D.20895>:
  D.26308 = 7;
  return D.26308;
  <D.20896>:
  D.26308 = 4;
  return D.26308;
  <D.20897>:
  <D.20898>:
  <D.20899>:
  D.26308 = 1;
  return D.26308;
  <D.20900>:
  D.26308 = 10;
  return D.26308;
  <D.20901>:
  D.26308 = 9;
  return D.26308;
  <D.20902>:
  D.26308 = 12;
  return D.26308;
  <D.20903>:
  D.26308 = 11;
  return D.26308;
  <D.20904>:
  D.26308 = 13;
  return D.26308;
  <D.20905>:
  D.26308 = 14;
  return D.26308;
  <D.20906>:
  {
    struct MonoClass * klass;

    D.26302 = type->type;
    klass = D.26302->data.klass;
    D.26309 = BIT_FIELD_REF <*klass, 32, 160>;
    D.26310 = D.26309 & 16;
    if (D.26310 != 0) goto <D.26311>; else goto <D.26312>;
    <D.26311>:
    D.26313 = mono_class_enum_basetype (klass);
    D.26314 = D.26313->type;
    t = (int) D.26314;
    goto handle_enum;
    <D.26312>:
    D.26315 = klass->image;
    D.26316 = mono_is_corlib_image (D.26315);
    if (D.26316 != 0) goto <D.26317>; else goto <D.26318>;
    <D.26317>:
    {
      size_t __s1_len;
      size_t __s2_len;

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

        __s2 = klass->name_space;
        D.26322 = "System";
        D.26323 = MEM[(const unsigned char *)D.26322];
        D.26324 = (int) D.26323;
        D.26325 = *__s2;
        D.26326 = (int) D.26325;
        __result = D.26324 - D.26326;
        {
          if (__s2_len != 0) goto <D.26327>; else goto <D.26328>;
          <D.26327>:
          if (__result == 0) goto <D.26329>; else goto <D.26330>;
          <D.26329>:
          D.26331 = &MEM[(void *)"System" + 1B];
          D.26332 = *D.26331;
          D.26333 = (int) D.26332;
          D.26334 = __s2 + 1;
          D.26335 = *D.26334;
          D.26336 = (int) D.26335;
          __result = D.26333 - D.26336;
          if (__s2_len > 1) goto <D.26337>; else goto <D.26338>;
          <D.26337>:
          if (__result == 0) goto <D.26339>; else goto <D.26340>;
          <D.26339>:
          D.26341 = &MEM[(void *)"System" + 2B];
          D.26342 = *D.26341;
          D.26343 = (int) D.26342;
          D.26344 = __s2 + 2;
          D.26345 = *D.26344;
          D.26346 = (int) D.26345;
          __result = D.26343 - D.26346;
          if (__s2_len > 2) goto <D.26347>; else goto <D.26348>;
          <D.26347>:
          if (__result == 0) goto <D.26349>; else goto <D.26350>;
          <D.26349>:
          D.26351 = &MEM[(void *)"System" + 3B];
          D.26352 = *D.26351;
          D.26353 = (int) D.26352;
          D.26354 = __s2 + 3;
          D.26355 = *D.26354;
          D.26356 = (int) D.26355;
          __result = D.26353 - D.26356;
          <D.26350>:
          <D.26348>:
          <D.26340>:
          <D.26338>:
          <D.26330>:
          <D.26328>:
        }
        D.20915 = __result;
      }
      iftmp.56 = -D.20915;
      goto <D.26357>;
      <D.26321>:
      D.26358 = klass->name_space;
      iftmp.56 = __builtin_strcmp (D.26358, "System");
      <D.26357>:
      D.20916 = iftmp.56;
    }
    if (D.20916 == 0) goto <D.26359>; else goto <D.26360>;
    <D.26359>:
    {
      size_t __s1_len;
      size_t __s2_len;

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

        __s2 = klass->name;
        D.26364 = "Decimal";
        D.26365 = MEM[(const unsigned char *)D.26364];
        D.26366 = (int) D.26365;
        D.26367 = *__s2;
        D.26368 = (int) D.26367;
        __result = D.26366 - D.26368;
        {
          if (__s2_len != 0) goto <D.26369>; else goto <D.26370>;
          <D.26369>:
          if (__result == 0) goto <D.26371>; else goto <D.26372>;
          <D.26371>:
          D.26373 = &MEM[(void *)"Decimal" + 1B];
          D.26374 = *D.26373;
          D.26375 = (int) D.26374;
          D.26376 = __s2 + 1;
          D.26377 = *D.26376;
          D.26378 = (int) D.26377;
          __result = D.26375 - D.26378;
          if (__s2_len > 1) goto <D.26379>; else goto <D.26380>;
          <D.26379>:
          if (__result == 0) goto <D.26381>; else goto <D.26382>;
          <D.26381>:
          D.26383 = &MEM[(void *)"Decimal" + 2B];
          D.26384 = *D.26383;
          D.26385 = (int) D.26384;
          D.26386 = __s2 + 2;
          D.26387 = *D.26386;
          D.26388 = (int) D.26387;
          __result = D.26385 - D.26388;
          if (__s2_len > 2) goto <D.26389>; else goto <D.26390>;
          <D.26389>:
          if (__result == 0) goto <D.26391>; else goto <D.26392>;
          <D.26391>:
          D.26393 = &MEM[(void *)"Decimal" + 3B];
          D.26394 = *D.26393;
          D.26395 = (int) D.26394;
          D.26396 = __s2 + 3;
          D.26397 = *D.26396;
          D.26398 = (int) D.26397;
          __result = D.26395 - D.26398;
          <D.26392>:
          <D.26390>:
          <D.26382>:
          <D.26380>:
          <D.26372>:
          <D.26370>:
        }
        D.20924 = __result;
      }
      iftmp.57 = -D.20924;
      goto <D.26399>;
      <D.26363>:
      D.26400 = klass->name;
      iftmp.57 = __builtin_strcmp (D.26400, "Decimal");
      <D.26399>:
      D.20925 = iftmp.57;
    }
    if (D.20925 == 0) goto <D.26401>; else goto <D.26402>;
    <D.26401>:
    D.26308 = 15;
    return D.26308;
    <D.26402>:
    {
      size_t __s1_len;
      size_t __s2_len;

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

        __s2 = klass->name;
        D.26406 = "DateTime";
        D.26407 = MEM[(const unsigned char *)D.26406];
        D.26408 = (int) D.26407;
        D.26409 = *__s2;
        D.26410 = (int) D.26409;
        __result = D.26408 - D.26410;
        {
          if (__s2_len != 0) goto <D.26411>; else goto <D.26412>;
          <D.26411>:
          if (__result == 0) goto <D.26413>; else goto <D.26414>;
          <D.26413>:
          D.26415 = &MEM[(void *)"DateTime" + 1B];
          D.26416 = *D.26415;
          D.26417 = (int) D.26416;
          D.26418 = __s2 + 1;
          D.26419 = *D.26418;
          D.26420 = (int) D.26419;
          __result = D.26417 - D.26420;
          if (__s2_len > 1) goto <D.26421>; else goto <D.26422>;
          <D.26421>:
          if (__result == 0) goto <D.26423>; else goto <D.26424>;
          <D.26423>:
          D.26425 = &MEM[(void *)"DateTime" + 2B];
          D.26426 = *D.26425;
          D.26427 = (int) D.26426;
          D.26428 = __s2 + 2;
          D.26429 = *D.26428;
          D.26430 = (int) D.26429;
          __result = D.26427 - D.26430;
          if (__s2_len > 2) goto <D.26431>; else goto <D.26432>;
          <D.26431>:
          if (__result == 0) goto <D.26433>; else goto <D.26434>;
          <D.26433>:
          D.26435 = &MEM[(void *)"DateTime" + 3B];
          D.26436 = *D.26435;
          D.26437 = (int) D.26436;
          D.26438 = __s2 + 3;
          D.26439 = *D.26438;
          D.26440 = (int) D.26439;
          __result = D.26437 - D.26440;
          <D.26434>:
          <D.26432>:
          <D.26424>:
          <D.26422>:
          <D.26414>:
          <D.26412>:
        }
        D.20933 = __result;
      }
      iftmp.58 = -D.20933;
      goto <D.26441>;
      <D.26405>:
      D.26400 = klass->name;
      iftmp.58 = __builtin_strcmp (D.26400, "DateTime");
      <D.26441>:
      D.20934 = iftmp.58;
    }
    if (D.20934 == 0) goto <D.26442>; else goto <D.26443>;
    <D.26442>:
    D.26308 = 16;
    return D.26308;
    <D.26443>:
    <D.26360>:
    <D.26318>:
    D.26308 = 1;
    return D.26308;
  }
  <D.20935>:
  D.26308 = 18;
  return D.26308;
  <D.20936>:
  <D.20937>:
  <D.20938>:
  <D.20939>:
  <D.20940>:
  <D.20941>:
  D.26308 = 1;
  return D.26308;
  <D.20942>:
  {
    struct MonoClass * klass;

    D.26302 = type->type;
    klass = D.26302->data.klass;
    D.26444 = klass->image;
    D.26445 = mono_defaults.corlib;
    if (D.26444 == D.26445) goto <D.26446>; else goto <D.26447>;
    <D.26446>:
    {
      size_t __s1_len;
      size_t __s2_len;

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

        __s2 = klass->name_space;
        D.26322 = "System";
        D.26323 = MEM[(const unsigned char *)D.26322];
        D.26324 = (int) D.26323;
        D.26451 = *__s2;
        D.26452 = (int) D.26451;
        __result = D.26324 - D.26452;
        {
          if (__s2_len != 0) goto <D.26453>; else goto <D.26454>;
          <D.26453>:
          if (__result == 0) goto <D.26455>; else goto <D.26456>;
          <D.26455>:
          D.26331 = &MEM[(void *)"System" + 1B];
          D.26332 = *D.26331;
          D.26333 = (int) D.26332;
          D.26457 = __s2 + 1;
          D.26458 = *D.26457;
          D.26459 = (int) D.26458;
          __result = D.26333 - D.26459;
          if (__s2_len > 1) goto <D.26460>; else goto <D.26461>;
          <D.26460>:
          if (__result == 0) goto <D.26462>; else goto <D.26463>;
          <D.26462>:
          D.26341 = &MEM[(void *)"System" + 2B];
          D.26342 = *D.26341;
          D.26343 = (int) D.26342;
          D.26464 = __s2 + 2;
          D.26465 = *D.26464;
          D.26466 = (int) D.26465;
          __result = D.26343 - D.26466;
          if (__s2_len > 2) goto <D.26467>; else goto <D.26468>;
          <D.26467>:
          if (__result == 0) goto <D.26469>; else goto <D.26470>;
          <D.26469>:
          D.26351 = &MEM[(void *)"System" + 3B];
          D.26352 = *D.26351;
          D.26353 = (int) D.26352;
          D.26471 = __s2 + 3;
          D.26472 = *D.26471;
          D.26473 = (int) D.26472;
          __result = D.26353 - D.26473;
          <D.26470>:
          <D.26468>:
          <D.26463>:
          <D.26461>:
          <D.26456>:
          <D.26454>:
        }
        D.20951 = __result;
      }
      iftmp.59 = -D.20951;
      goto <D.26474>;
      <D.26450>:
      D.26475 = klass->name_space;
      iftmp.59 = __builtin_strcmp (D.26475, "System");
      <D.26474>:
      D.20952 = iftmp.59;
    }
    if (D.20952 == 0) goto <D.26476>; else goto <D.26477>;
    <D.26476>:
    {
      size_t __s1_len;
      size_t __s2_len;

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

        __s2 = klass->name;
        D.26481 = "DBNull";
        D.26482 = MEM[(const unsigned char *)D.26481];
        D.26483 = (int) D.26482;
        D.26484 = *__s2;
        D.26485 = (int) D.26484;
        __result = D.26483 - D.26485;
        {
          if (__s2_len != 0) goto <D.26486>; else goto <D.26487>;
          <D.26486>:
          if (__result == 0) goto <D.26488>; else goto <D.26489>;
          <D.26488>:
          D.26490 = &MEM[(void *)"DBNull" + 1B];
          D.26491 = *D.26490;
          D.26492 = (int) D.26491;
          D.26493 = __s2 + 1;
          D.26494 = *D.26493;
          D.26495 = (int) D.26494;
          __result = D.26492 - D.26495;
          if (__s2_len > 1) goto <D.26496>; else goto <D.26497>;
          <D.26496>:
          if (__result == 0) goto <D.26498>; else goto <D.26499>;
          <D.26498>:
          D.26500 = &MEM[(void *)"DBNull" + 2B];
          D.26501 = *D.26500;
          D.26502 = (int) D.26501;
          D.26503 = __s2 + 2;
          D.26504 = *D.26503;
          D.26505 = (int) D.26504;
          __result = D.26502 - D.26505;
          if (__s2_len > 2) goto <D.26506>; else goto <D.26507>;
          <D.26506>:
          if (__result == 0) goto <D.26508>; else goto <D.26509>;
          <D.26508>:
          D.26510 = &MEM[(void *)"DBNull" + 3B];
          D.26511 = *D.26510;
          D.26512 = (int) D.26511;
          D.26513 = __s2 + 3;
          D.26514 = *D.26513;
          D.26515 = (int) D.26514;
          __result = D.26512 - D.26515;
          <D.26509>:
          <D.26507>:
          <D.26499>:
          <D.26497>:
          <D.26489>:
          <D.26487>:
        }
        D.20960 = __result;
      }
      iftmp.60 = -D.20960;
      goto <D.26516>;
      <D.26480>:
      D.26517 = klass->name;
      iftmp.60 = __builtin_strcmp (D.26517, "DBNull");
      <D.26516>:
      D.20961 = iftmp.60;
    }
    if (D.20961 == 0) goto <D.26518>; else goto <D.26519>;
    <D.26518>:
    D.26308 = 2;
    return D.26308;
    <D.26519>:
    <D.26477>:
    <D.26447>:
  }
  D.26308 = 1;
  return D.26308;
  <D.20962>:
  D.26308 = 1;
  return D.26308;
  <D.20963>:
  monoeg_g_log (0B, 4, "type 0x%02x not handled in GetTypeCode()", t);
  <D.20964>:
  goto <D.20964>;
  D.26308 = 0;
  return D.26308;
}


ves_icall_Type_GetPacking (struct MonoReflectionType * type, guint32 * packing, guint32 * size)
{
  struct MonoType * D.26521;
  struct MonoImage * D.26522;
  unsigned int D.26523;
  unsigned int D.26524;
  int D.26527;
  unsigned int D.26528;
  int D.26529;
  unsigned int D.26530;
  unsigned int D.26532;
  struct MonoClass * klass;

  D.26521 = type->type;
  klass = mono_class_from_mono_type (D.26521);
  mono_class_init_or_throw (klass);
  D.26522 = klass->image;
  D.26523 = BIT_FIELD_REF <*D.26522, 32, 128>;
  D.26524 = D.26523 & 8;
  if (D.26524 != 0) goto <D.26525>; else goto <D.26526>;
  <D.26525>:
  {
    struct MonoReflectionTypeBuilder * tb;

    tb = type;
    D.26527 = tb->packing_size;
    D.26528 = (unsigned int) D.26527;
    *packing = D.26528;
    D.26529 = tb->class_size;
    D.26530 = (unsigned int) D.26529;
    *size = D.26530;
  }
  goto <D.26531>;
  <D.26526>:
  D.26522 = klass->image;
  D.26532 = klass->type_token;
  mono_metadata_packing_from_typedef (D.26522, D.26532, packing, size);
  <D.26531>:
}


ves_icall_Type_GetInterfaceMapData (struct MonoReflectionType * type, struct MonoReflectionType * iface, struct MonoArray * * targets, struct MonoArray * * methods)
{
  struct MonoType * D.26533;
  struct MonoType * D.26534;
  struct MonoVTable * D.26537;
  struct MonoClass * D.26538;
  unsigned int len.61;
  struct MonoArray * D.26540;
  struct MonoArray * D.26541;
  struct MonoArray * D.26542;
  unsigned int i.62;
  struct MonoMethod * * D.26544;
  int D.26545;
  unsigned int D.26546;
  unsigned int D.26547;
  struct MonoMethod * * D.26548;
  struct MonoMethod * D.26549;
  struct MonoArray * D.26550;
  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.26533 = type->type;
      class = mono_class_from_mono_type (D.26533);
      D.26534 = iface->type;
      iclass = mono_class_from_mono_type (D.26534);
      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.26535>; else goto <D.26536>;
      <D.26535>:
      return;
      <D.26536>:
      len = mono_class_num_methods (iclass);
      D.26537 = MEM[(struct MonoObject *)type].vtable;
      domain = D.26537->domain;
      D.26538 = mono_defaults.method_info_class;
      len.61 = (unsigned int) len;
      D.26540 = mono_array_new (domain, D.26538, len.61);
      mono_gc_wbarrier_generic_store (targets, D.26540);
      D.26538 = mono_defaults.method_info_class;
      len.61 = (unsigned int) len;
      D.26541 = mono_array_new (domain, D.26538, len.61);
      mono_gc_wbarrier_generic_store (methods, D.26541);
      iter = 0B;
      goto <D.21233>;
      <D.21232>:
      member = mono_method_get_object (domain, method, iclass);
      {
        void * * __p;

        D.26542 = *methods;
        i.62 = (unsigned int) i;
        __p = mono_array_addr_with_size (D.26542, 4, i.62);
        D.26542 = *methods;
        mono_gc_wbarrier_set_arrayref (D.26542, __p, member);
      }
      D.26544 = class->vtable;
      D.26545 = i + ioffset;
      D.26546 = (unsigned int) D.26545;
      D.26547 = D.26546 * 4;
      D.26548 = D.26544 + D.26547;
      D.26549 = *D.26548;
      member = mono_method_get_object (domain, D.26549, class);
      {
        void * * __p;

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


ves_icall_Type_GetGenericTypeDefinition_impl (struct MonoReflectionType * type)
{
  struct MonoType * D.26554;
  unsigned int D.26555;
  unsigned int D.26556;
  struct MonoReflectionType * D.26559;
  struct MonoGenericContainer * D.26560;
  struct MonoGenericClass * D.26563;
  unsigned int D.26567;
  unsigned int D.26568;
  struct MonoVTable * D.26571;
  struct MonoDomain * D.26572;
  struct MonoType * D.26573;
  struct MonoClass * klass;

  D.26554 = type->type;
  D.26555 = BIT_FIELD_REF <*D.26554, 32, 32>;
  D.26556 = D.26555 & 1073741824;
  if (D.26556 != 0) goto <D.26557>; else goto <D.26558>;
  <D.26557>:
  D.26559 = 0B;
  return D.26559;
  <D.26558>:
  D.26554 = type->type;
  klass = mono_class_from_mono_type (D.26554);
  D.26560 = klass->generic_container;
  if (D.26560 != 0B) goto <D.26561>; else goto <D.26562>;
  <D.26561>:
  D.26559 = type;
  return D.26559;
  <D.26562>:
  D.26563 = klass->generic_class;
  if (D.26563 != 0B) goto <D.26564>; else goto <D.26565>;
  <D.26564>:
  {
    struct MonoClass * generic_class;
    void * tb;

    D.26563 = klass->generic_class;
    generic_class = D.26563->container_class;
    tb = mono_class_get_ref_info (generic_class);
    D.26567 = BIT_FIELD_REF <*generic_class, 32, 160>;
    D.26568 = D.26567 & 128;
    if (D.26568 != 0) goto <D.26569>; else goto <D.26566>;
    <D.26569>:
    if (tb != 0B) goto <D.26570>; else goto <D.26566>;
    <D.26570>:
    D.26559 = tb;
    return D.26559;
    <D.26566>:
    D.26571 = MEM[(struct MonoObject *)type].vtable;
    D.26572 = D.26571->domain;
    D.26573 = &generic_class->byval_arg;
    D.26559 = mono_type_get_object (D.26572, D.26573);
    return D.26559;
  }
  <D.26565>:
  D.26559 = 0B;
  return D.26559;
}


ves_icall_Type_GetGenericParameterPosition (struct MonoReflectionType * type)
{
  struct MonoVTable * D.26579;
  struct MonoClass * D.26580;
  struct MonoImage * D.26581;
  struct MonoImage * D.26582;
  struct MonoType * D.26584;
  gint32 D.26585;
  unsigned char D.26586;
  struct MonoGenericParam * D.26589;
  short unsigned int D.26590;

  if (type != 0B) goto <D.26577>; else goto <D.26578>;
  <D.26577>:
  D.26579 = MEM[(struct MonoObject *)type].vtable;
  D.26580 = D.26579->klass;
  D.26581 = D.26580->image;
  D.26582 = mono_defaults.corlib;
  if (D.26581 != D.26582) goto <D.26575>; else goto <D.26583>;
  <D.26583>:
  D.26584 = type->type;
  if (D.26584 == 0B) goto <D.26575>; else goto <D.26576>;
  <D.26575>:
  D.26585 = -1;
  return D.26585;
  <D.26576>:
  <D.26578>:
  D.26584 = type->type;
  D.26586 = is_generic_parameter (D.26584);
  if (D.26586 != 0) goto <D.26587>; else goto <D.26588>;
  <D.26587>:
  D.26584 = type->type;
  D.26589 = D.26584->data.generic_param;
  D.26590 = D.26589->num;
  D.26585 = (gint32) D.26590;
  return D.26585;
  <D.26588>:
  D.26585 = -1;
  return D.26585;
}


ves_icall_Type_GetGenericParameterConstraints (struct MonoReflectionType * type)
{
  int iftmp.63;
  struct MonoVTable * D.26597;
  struct MonoClass * D.26598;
  struct MonoImage * D.26599;
  struct MonoImage * D.26600;
  struct MonoType * D.26602;
  _Bool D.26603;
  long int D.26604;
  long int D.26605;
  struct MonoGenericParamInfo * iftmp.64;
  struct MonoGenericParam * D.26609;
  struct MonoGenericContainer * D.26610;
  struct MonoClass * D.26615;
  struct MonoClass * D.26616;
  unsigned int count.65;
  unsigned int i.66;
  struct MonoClass * * D.26619;
  unsigned int i.67;
  unsigned int D.26621;
  struct MonoClass * * D.26622;
  struct MonoClass * D.26623;
  struct MonoType * D.26624;
  struct MonoReflectionType * D.26625;
  struct MonoArray * D.26626;
  struct MonoGenericParamInfo * param_info;
  struct MonoDomain * domain;
  struct MonoClass * * ptr;
  struct MonoArray * res;
  int i;
  int count;

  if (type != 0B) goto <D.26596>; else goto <D.26593>;
  <D.26596>:
  D.26597 = MEM[(struct MonoObject *)type].vtable;
  D.26598 = D.26597->klass;
  D.26599 = D.26598->image;
  D.26600 = mono_defaults.corlib;
  if (D.26599 != D.26600) goto <D.26594>; else goto <D.26601>;
  <D.26601>:
  D.26602 = type->type;
  if (D.26602 == 0B) goto <D.26594>; else goto <D.26593>;
  <D.26594>:
  iftmp.63 = 1;
  goto <D.26595>;
  <D.26593>:
  iftmp.63 = 0;
  <D.26595>:
  D.26603 = iftmp.63 != 0;
  D.26604 = (long int) D.26603;
  D.26605 = __builtin_expect (D.26604, 0);
  if (D.26605 != 0) goto <D.26606>; else goto <D.26607>;
  <D.26606>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "icall.c", 2493, "IS_MONOTYPE (type)");
  <D.26607>:
  D.26597 = MEM[(struct MonoObject *)type].vtable;
  domain = D.26597->domain;
  D.26602 = type->type;
  D.26609 = D.26602->data.generic_param;
  D.26610 = D.26609->owner;
  if (D.26610 != 0B) goto <D.26611>; else goto <D.26612>;
  <D.26611>:
  D.26602 = type->type;
  D.26609 = D.26602->data.generic_param;
  iftmp.64 = &MEM[(struct MonoGenericParamFull *)D.26609].info;
  goto <D.26613>;
  <D.26612>:
  iftmp.64 = 0B;
  <D.26613>:
  param_info = iftmp.64;
  count = 0;
  ptr = param_info->constraints;
  goto <D.21364>;
  <D.21363>:
  ptr = ptr + 4;
  count = count + 1;
  <D.21364>:
  if (ptr != 0B) goto <D.26614>; else goto <D.21365>;
  <D.26614>:
  D.26615 = *ptr;
  if (D.26615 != 0B) goto <D.21363>; else goto <D.21365>;
  <D.21365>:
  D.26616 = mono_defaults.monotype_class;
  count.65 = (unsigned int) count;
  res = mono_array_new (domain, D.26616, count.65);
  i = 0;
  goto <D.21368>;
  <D.21367>:
  {
    void * * __p;

    i.66 = (unsigned int) i;
    __p = mono_array_addr_with_size (res, 4, i.66);
    D.26619 = param_info->constraints;
    i.67 = (unsigned int) i;
    D.26621 = i.67 * 4;
    D.26622 = D.26619 + D.26621;
    D.26623 = *D.26622;
    D.26624 = &D.26623->byval_arg;
    D.26625 = mono_type_get_object (domain, D.26624);
    mono_gc_wbarrier_set_arrayref (res, __p, D.26625);
  }
  i = i + 1;
  <D.21368>:
  if (i < count) goto <D.21367>; else goto <D.21369>;
  <D.21369>:
  D.26626 = res;
  return D.26626;
}


ves_icall_Type_GetGenericParameterAttributes (struct MonoReflectionType * type)
{
  int iftmp.68;
  struct MonoVTable * D.26633;
  struct MonoClass * D.26634;
  struct MonoImage * D.26635;
  struct MonoImage * D.26636;
  struct MonoType * D.26638;
  _Bool D.26639;
  long int D.26640;
  long int D.26641;
  unsigned char D.26644;
  _Bool D.26645;
  long int D.26646;
  long int D.26647;
  GenericParameterAttributes D.26650;
  struct MonoGenericParamInfo * iftmp.69;
  struct MonoGenericParam * D.26652;
  struct MonoGenericContainer * D.26653;
  short unsigned int D.26657;

  if (type != 0B) goto <D.26632>; else goto <D.26629>;
  <D.26632>:
  D.26633 = MEM[(struct MonoObject *)type].vtable;
  D.26634 = D.26633->klass;
  D.26635 = D.26634->image;
  D.26636 = mono_defaults.corlib;
  if (D.26635 != D.26636) goto <D.26630>; else goto <D.26637>;
  <D.26637>:
  D.26638 = type->type;
  if (D.26638 == 0B) goto <D.26630>; else goto <D.26629>;
  <D.26630>:
  iftmp.68 = 1;
  goto <D.26631>;
  <D.26629>:
  iftmp.68 = 0;
  <D.26631>:
  D.26639 = iftmp.68 != 0;
  D.26640 = (long int) D.26639;
  D.26641 = __builtin_expect (D.26640, 0);
  if (D.26641 != 0) goto <D.26642>; else goto <D.26643>;
  <D.26642>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "icall.c", 2477, "IS_MONOTYPE (type)");
  <D.26643>:
  D.26638 = type->type;
  D.26644 = is_generic_parameter (D.26638);
  D.26645 = D.26644 == 0;
  D.26646 = (long int) D.26645;
  D.26647 = __builtin_expect (D.26646, 0);
  if (D.26647 != 0) goto <D.26648>; else goto <D.26649>;
  <D.26648>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "icall.c", 2478, "is_generic_parameter (type->type)");
  <D.26649>:
  D.26638 = type->type;
  D.26652 = D.26638->data.generic_param;
  D.26653 = D.26652->owner;
  if (D.26653 != 0B) goto <D.26654>; else goto <D.26655>;
  <D.26654>:
  D.26638 = type->type;
  D.26652 = D.26638->data.generic_param;
  iftmp.69 = &MEM[(struct MonoGenericParamFull *)D.26652].info;
  goto <D.26656>;
  <D.26655>:
  iftmp.69 = 0B;
  <D.26656>:
  D.26657 = iftmp.69->flags;
  D.26650 = (GenericParameterAttributes) D.26657;
  return D.26650;
}


ves_icall_System_Type_EqualsInternal (struct MonoReflectionType * type, struct MonoReflectionType * c)
{
  struct MonoType * D.26661;
  struct MonoType * D.26663;
  MonoBoolean D.26665;
  int D.26666;
  _Bool D.26667;

  if (c != 0B) goto <D.26660>; else goto <D.26659>;
  <D.26660>:
  D.26661 = type->type;
  if (D.26661 != 0B) goto <D.26662>; else goto <D.26659>;
  <D.26662>:
  D.26663 = c->type;
  if (D.26663 != 0B) goto <D.26664>; else goto <D.26659>;
  <D.26664>:
  D.26661 = type->type;
  D.26663 = c->type;
  D.26666 = mono_metadata_type_equal (D.26661, D.26663);
  D.26665 = (MonoBoolean) D.26666;
  return D.26665;
  <D.26659>:
  D.26667 = type == c;
  D.26665 = (MonoBoolean) D.26667;
  return D.26665;
}


ves_icall_System_Text_Encoding_InternalCodePage (gint32 * int_code_page)
{
  const char * cset.70;
  char D.26670;
  const short unsigned int * * D.26673;
  const short unsigned int * D.26674;
  unsigned int D.26675;
  unsigned int D.26676;
  const short unsigned int * D.26677;
  short unsigned int D.26678;
  int D.26679;
  int D.26680;
  int D.22915;
  int D.26685;
  int D.26686;
  const int iftmp.71;
  unsigned int __c.72;
  unsigned int D.26691;
  const __int32_t * * D.26694;
  const __int32_t * D.26695;
  unsigned int __c.73;
  unsigned int D.26697;
  const __int32_t * D.26698;
  unsigned int D.26702;
  const __int32_t * D.26703;
  char D.26704;
  int p.74;
  int D.22928;
  char * D.26712;
  int D.26715;
  int D.26716;
  struct MonoString * D.26720;
  struct MonoDomain * D.26721;
  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.22917>;
      <D.22916>:
      D.26670 = *c;
      if (D.26670 >= 0) goto <D.26671>; else goto <D.26672>;
      <D.26671>:
      D.26673 = __ctype_b_loc ();
      D.26674 = *D.26673;
      D.26670 = *c;
      D.26675 = (unsigned int) D.26670;
      D.26676 = D.26675 * 2;
      D.26677 = D.26674 + D.26676;
      D.26678 = *D.26677;
      D.26679 = (int) D.26678;
      D.26680 = D.26679 & 1024;
      if (D.26680 != 0) goto <D.26681>; else goto <D.26682>;
      <D.26681>:
      {
        int __res;

        {
          if (0 != 0) goto <D.26683>; else goto <D.26684>;
          <D.26683>:
          D.26670 = *c;
          D.26685 = (int) D.26670;
          D.26686 = __builtin_constant_p (D.26685);
          if (D.26686 != 0) goto <D.26687>; else goto <D.26688>;
          <D.26687>:
          {
            int __c;

            D.26670 = *c;
            __c = (int) D.26670;
            __c.72 = (unsigned int) __c;
            D.26691 = __c.72 + 128;
            if (D.26691 <= 383) goto <D.26692>; else goto <D.26693>;
            <D.26692>:
            D.26694 = __ctype_tolower_loc ();
            D.26695 = *D.26694;
            __c.73 = (unsigned int) __c;
            D.26697 = __c.73 * 4;
            D.26698 = D.26695 + D.26697;
            iftmp.71 = *D.26698;
            goto <D.26699>;
            <D.26693>:
            iftmp.71 = __c;
            <D.26699>:
            __res = iftmp.71;
          }
          goto <D.26700>;
          <D.26688>:
          D.26670 = *c;
          D.26685 = (int) D.26670;
          __res = tolower (D.26685);
          <D.26700>:
          goto <D.26701>;
          <D.26684>:
          D.26694 = __ctype_tolower_loc ();
          D.26695 = *D.26694;
          D.26670 = *c;
          D.26675 = (unsigned int) D.26670;
          D.26702 = D.26675 * 4;
          D.26703 = D.26695 + D.26702;
          __res = *D.26703;
          <D.26701>:
        }
        D.22915 = __res;
      }
      D.26704 = (char) D.22915;
      *c = D.26704;
      <D.26682>:
      <D.26672>:
      D.26670 = *c;
      if (D.26670 == 45) goto <D.26705>; else goto <D.26706>;
      <D.26705>:
      *c = 95;
      <D.26706>:
      c = c + 1;
      <D.22917>:
      D.26670 = *c;
      if (D.26670 != 0) goto <D.22916>; else goto <D.22918>;
      <D.22918>:
      p = encodings[0];
      code = 0;
      i = 0;
      goto <D.22919>;
      <D.22930>:
      p.74 = (int) p;
      if (p.74 <= 6) goto <D.26708>; else goto <D.26709>;
      <D.26708>:
      code = (int) p;
      i = i + 1;
      p = encodings[i];
      // predicted unlikely by continue predictor.
      goto <D.22919>;
      <D.26709>:
      {
        size_t __s1_len;
        size_t __s2_len;

        D.22928 = __builtin_strcmp (p, codepage);
      }
      if (D.22928 == 0) goto <D.26710>; else goto <D.26711>;
      <D.26710>:
      *int_code_page = code;
      goto <D.22929>;
      <D.26711>:
      i = i + 1;
      p = encodings[i];
      <D.22919>:
      if (p != 0B) goto <D.22930>; else goto <D.22929>;
      <D.22929>:
      D.26712 = strstr (codepage, "utf_8");
      if (D.26712 != 0B) goto <D.26713>; else goto <D.26714>;
      <D.26713>:
      D.26715 = *int_code_page;
      D.26716 = D.26715 | 268435456;
      *int_code_page = D.26716;
      <D.26714>:
      free (codepage);
      if (want_name != 0) goto <D.26718>; else goto <D.26717>;
      <D.26718>:
      D.26715 = *int_code_page;
      if (D.26715 == -1) goto <D.26719>; else goto <D.26717>;
      <D.26719>:
      D.26721 = mono_domain_get ();
      cset.70 = cset;
      D.26720 = mono_string_new (D.26721, cset.70);
      return D.26720;
      <D.26717>:
      D.26720 = 0B;
      return D.26720;
    }
  finally
    {
      cset = {CLOBBER};
    }
}


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

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


ves_icall_IsTransparentProxy (struct MonoObject * proxy)
{
  MonoBoolean D.26728;
  struct MonoVTable * D.26729;
  struct MonoClass * D.26730;
  struct MonoClass * D.26731;

  if (proxy == 0B) goto <D.26726>; else goto <D.26727>;
  <D.26726>:
  D.26728 = 0;
  return D.26728;
  <D.26727>:
  D.26729 = proxy->vtable;
  D.26730 = D.26729->klass;
  D.26731 = mono_defaults.transparent_proxy_class;
  if (D.26730 == D.26731) goto <D.26732>; else goto <D.26733>;
  <D.26732>:
  D.26728 = 1;
  return D.26728;
  <D.26733>:
  D.26728 = 0;
  return D.26728;
}


ves_icall_InternalExecute (struct MonoReflectionMethod * method, struct MonoObject * this, struct MonoArray * params, struct MonoArray * * outArgs)
{
  struct MonoVTable * D.26735;
  struct MonoClass * D.26736;
  struct MonoClass * D.26737;
  int D.21515;
  int iftmp.75;
  int D.21514;
  const char[12] * D.26743;
  unsigned char D.26744;
  int D.26745;
  unsigned char D.26746;
  int D.26747;
  const unsigned char * D.26752;
  unsigned char D.26753;
  int D.26754;
  const unsigned char * D.26755;
  unsigned char D.26756;
  int D.26757;
  const unsigned char * D.26762;
  unsigned char D.26763;
  int D.26764;
  const unsigned char * D.26765;
  unsigned char D.26766;
  int D.26767;
  const unsigned char * D.26772;
  unsigned char D.26773;
  int D.26774;
  const unsigned char * D.26775;
  unsigned char D.26776;
  int D.26777;
  const char * D.26779;
  struct MonoVTable * D.26782;
  struct MonoClass * D.26783;
  struct MonoRealProxy * D.26786;
  _Bool D.26787;
  long int D.26788;
  long int D.26789;
  char * D.26792;
  struct MonoType * D.26795;
  unsigned int D.26796;
  unsigned int D.26797;
  int D.26800;
  sizetype D.26801;
  void * D.26802;
  void * * D.26804;
  struct MonoObject * D.26805;
  int D.21533;
  int iftmp.76;
  int D.21532;
  const char[12] * D.26809;
  unsigned char D.26810;
  int D.26811;
  unsigned char D.26812;
  int D.26813;
  const unsigned char * D.26818;
  unsigned char D.26819;
  int D.26820;
  const unsigned char * D.26821;
  unsigned char D.26822;
  int D.26823;
  const unsigned char * D.26828;
  unsigned char D.26829;
  int D.26830;
  const unsigned char * D.26831;
  unsigned char D.26832;
  int D.26833;
  const unsigned char * D.26838;
  unsigned char D.26839;
  int D.26840;
  const unsigned char * D.26841;
  unsigned char D.26842;
  int D.26843;
  struct MonoRealProxy * D.26849;
  char * D.26852;
  struct MonoType * D.26855;
  char * D.26856;
  unsigned int D.26857;
  unsigned int D.26858;
  int D.26861;
  int D.26862;
  unsigned int D.26863;
  _Bool D.26864;
  long int D.26865;
  long int D.26866;
  int D.26869;
  sizetype D.26870;
  void * D.26871;
  void * D.26872;
  struct MonoType * D.26874;
  unsigned int D.26875;
  unsigned int D.26876;
  unsigned int i.77;
  unsigned int D.26880;
  unsigned int outarg_count.78;
  int D.21556;
  int iftmp.79;
  int D.21555;
  struct MonoMethod * D.26885;
  const char[6] * D.26886;
  unsigned char D.26887;
  int D.26888;
  unsigned char D.26889;
  int D.26890;
  const unsigned char * D.26895;
  unsigned char D.26896;
  int D.26897;
  const unsigned char * D.26898;
  unsigned char D.26899;
  int D.26900;
  const unsigned char * D.26905;
  unsigned char D.26906;
  int D.26907;
  const unsigned char * D.26908;
  unsigned char D.26909;
  int D.26910;
  const unsigned char * D.26915;
  unsigned char D.26916;
  int D.26917;
  const unsigned char * D.26918;
  unsigned char D.26919;
  int D.26920;
  const char * D.26922;
  struct MonoClass * D.26927;
  unsigned int D.26928;
  unsigned int D.26929;
  _Bool D.26930;
  long int D.26931;
  long int D.26932;
  char * D.26937;
  unsigned int j.80;
  unsigned int D.26939;
  struct MonoDomain * domain;
  struct MonoMethod * m;
  struct MonoMethodSignature * sig;
  struct MonoArray * out_args;
  struct MonoObject * result;
  int i;
  int j;
  int outarg_count;

  D.26735 = MEM[(struct MonoObject *)method].vtable;
  domain = D.26735->domain;
  m = method->method;
  sig = mono_method_signature (m);
  outarg_count = 0;
  D.26736 = m->klass;
  D.26737 = mono_defaults.object_class;
  if (D.26736 == D.26737) goto <D.26738>; else goto <D.26739>;
  <D.26738>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = m->name;
      D.26743 = "FieldGetter";
      D.26744 = MEM[(const unsigned char *)D.26743];
      D.26745 = (int) D.26744;
      D.26746 = *__s2;
      D.26747 = (int) D.26746;
      __result = D.26745 - D.26747;
      {
        if (__s2_len != 0) goto <D.26748>; else goto <D.26749>;
        <D.26748>:
        if (__result == 0) goto <D.26750>; else goto <D.26751>;
        <D.26750>:
        D.26752 = &MEM[(void *)"FieldGetter" + 1B];
        D.26753 = *D.26752;
        D.26754 = (int) D.26753;
        D.26755 = __s2 + 1;
        D.26756 = *D.26755;
        D.26757 = (int) D.26756;
        __result = D.26754 - D.26757;
        if (__s2_len > 1) goto <D.26758>; else goto <D.26759>;
        <D.26758>:
        if (__result == 0) goto <D.26760>; else goto <D.26761>;
        <D.26760>:
        D.26762 = &MEM[(void *)"FieldGetter" + 2B];
        D.26763 = *D.26762;
        D.26764 = (int) D.26763;
        D.26765 = __s2 + 2;
        D.26766 = *D.26765;
        D.26767 = (int) D.26766;
        __result = D.26764 - D.26767;
        if (__s2_len > 2) goto <D.26768>; else goto <D.26769>;
        <D.26768>:
        if (__result == 0) goto <D.26770>; else goto <D.26771>;
        <D.26770>:
        D.26772 = &MEM[(void *)"FieldGetter" + 3B];
        D.26773 = *D.26772;
        D.26774 = (int) D.26773;
        D.26775 = __s2 + 3;
        D.26776 = *D.26775;
        D.26777 = (int) D.26776;
        __result = D.26774 - D.26777;
        <D.26771>:
        <D.26769>:
        <D.26761>:
        <D.26759>:
        <D.26751>:
        <D.26749>:
      }
      D.21514 = __result;
    }
    iftmp.75 = -D.21514;
    goto <D.26778>;
    <D.26742>:
    D.26779 = m->name;
    iftmp.75 = __builtin_strcmp (D.26779, "FieldGetter");
    <D.26778>:
    D.21515 = iftmp.75;
  }
  if (D.21515 == 0) goto <D.26780>; else goto <D.26781>;
  <D.26780>:
  {
    struct MonoClass * k;
    struct MonoString * name;
    char * str;

    D.26782 = this->vtable;
    k = D.26782->klass;
    D.26783 = mono_defaults.transparent_proxy_class;
    if (D.26783 == k) goto <D.26784>; else goto <D.26785>;
    <D.26784>:
    {
      struct MonoTransparentProxy * tp;

      tp = this;
      D.26786 = tp->rp;
      this = D.26786->unwrapped_server;
      D.26787 = this == 0B;
      D.26788 = (long int) D.26787;
      D.26789 = __builtin_expect (D.26788, 0);
      if (D.26789 != 0) goto <D.26790>; else goto <D.26791>;
      <D.26790>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "icall.c", 2870, "this");
      <D.26791>:
      D.26782 = this->vtable;
      k = D.26782->klass;
    }
    <D.26785>:
    D.26792 = mono_array_addr_with_size (params, 4, 1);
    name = MEM[(struct MonoString * *)D.26792];
    str = mono_string_to_utf8 (name);
    <D.21523>:
    {
      struct MonoClassField * field;

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

        D.26795 = field->type;
        field_klass = mono_class_from_mono_type (D.26795);
        D.26796 = BIT_FIELD_REF <*field_klass, 32, 160>;
        D.26797 = D.26796 & 8;
        if (D.26797 != 0) goto <D.26798>; else goto <D.26799>;
        <D.26798>:
        D.26800 = field->offset;
        D.26801 = (sizetype) D.26800;
        D.26802 = this + D.26801;
        result = mono_value_box (domain, field_klass, D.26802);
        goto <D.26803>;
        <D.26799>:
        D.26800 = field->offset;
        D.26801 = (sizetype) D.26800;
        D.26804 = this + D.26801;
        result = *D.26804;
        <D.26803>:
        D.26737 = mono_defaults.object_class;
        out_args = mono_array_new (domain, D.26737, 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.26805 = 0B;
        return D.26805;
      }
      <D.26794>:
      k = k->parent;
    }
    if (k != 0B) goto <D.21523>; else goto <D.21524>;
    <D.21524>:
    monoeg_g_free (str);
    monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "icall.c", 2896);
  }
  <D.26781>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = m->name;
      D.26809 = "FieldSetter";
      D.26810 = MEM[(const unsigned char *)D.26809];
      D.26811 = (int) D.26810;
      D.26812 = *__s2;
      D.26813 = (int) D.26812;
      __result = D.26811 - D.26813;
      {
        if (__s2_len != 0) goto <D.26814>; else goto <D.26815>;
        <D.26814>:
        if (__result == 0) goto <D.26816>; else goto <D.26817>;
        <D.26816>:
        D.26818 = &MEM[(void *)"FieldSetter" + 1B];
        D.26819 = *D.26818;
        D.26820 = (int) D.26819;
        D.26821 = __s2 + 1;
        D.26822 = *D.26821;
        D.26823 = (int) D.26822;
        __result = D.26820 - D.26823;
        if (__s2_len > 1) goto <D.26824>; else goto <D.26825>;
        <D.26824>:
        if (__result == 0) goto <D.26826>; else goto <D.26827>;
        <D.26826>:
        D.26828 = &MEM[(void *)"FieldSetter" + 2B];
        D.26829 = *D.26828;
        D.26830 = (int) D.26829;
        D.26831 = __s2 + 2;
        D.26832 = *D.26831;
        D.26833 = (int) D.26832;
        __result = D.26830 - D.26833;
        if (__s2_len > 2) goto <D.26834>; else goto <D.26835>;
        <D.26834>:
        if (__result == 0) goto <D.26836>; else goto <D.26837>;
        <D.26836>:
        D.26838 = &MEM[(void *)"FieldSetter" + 3B];
        D.26839 = *D.26838;
        D.26840 = (int) D.26839;
        D.26841 = __s2 + 3;
        D.26842 = *D.26841;
        D.26843 = (int) D.26842;
        __result = D.26840 - D.26843;
        <D.26837>:
        <D.26835>:
        <D.26827>:
        <D.26825>:
        <D.26817>:
        <D.26815>:
      }
      D.21532 = __result;
    }
    iftmp.76 = -D.21532;
    goto <D.26844>;
    <D.26808>:
    D.26779 = m->name;
    iftmp.76 = __builtin_strcmp (D.26779, "FieldSetter");
    <D.26844>:
    D.21533 = iftmp.76;
  }
  if (D.21533 == 0) goto <D.26845>; else goto <D.26846>;
  <D.26845>:
  {
    struct MonoClass * k;
    struct MonoString * name;
    guint32 size;
    gint32 align;
    char * str;

    try
      {
        D.26782 = this->vtable;
        k = D.26782->klass;
        D.26783 = mono_defaults.transparent_proxy_class;
        if (D.26783 == k) goto <D.26847>; else goto <D.26848>;
        <D.26847>:
        {
          struct MonoTransparentProxy * tp;

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

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

            D.26855 = field->type;
            field_klass = mono_class_from_mono_type (D.26855);
            D.26856 = mono_array_addr_with_size (params, 4, 2);
            val = MEM[(void * *)D.26856];
            D.26857 = BIT_FIELD_REF <*field_klass, 32, 160>;
            D.26858 = D.26857 & 8;
            if (D.26858 != 0) goto <D.26859>; else goto <D.26860>;
            <D.26859>:
            D.26855 = field->type;
            D.26861 = mono_type_size (D.26855, &align);
            size = (guint32) D.26861;
            D.26862 = mono_class_value_size (field_klass, 0B);
            D.26863 = (unsigned int) D.26862;
            D.26864 = D.26863 != size;
            D.26865 = (long int) D.26864;
            D.26866 = __builtin_expect (D.26865, 0);
            if (D.26866 != 0) goto <D.26867>; else goto <D.26868>;
            <D.26867>:
            monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "icall.c", 2924, "size == mono_class_value_size (field_klass, NULL)");
            <D.26868>:
            D.26869 = field->offset;
            D.26870 = (sizetype) D.26869;
            D.26871 = this + D.26870;
            D.26872 = val + 8;
            mono_gc_wbarrier_value_copy (D.26871, D.26872, 1, field_klass);
            goto <D.26873>;
            <D.26860>:
            D.26869 = field->offset;
            D.26870 = (sizetype) D.26869;
            D.26871 = this + D.26870;
            mono_gc_wbarrier_set_field (this, D.26871, val);
            <D.26873>:
            D.26737 = mono_defaults.object_class;
            out_args = mono_array_new (domain, D.26737, 0);
            mono_gc_wbarrier_generic_store (outArgs, out_args);
            monoeg_g_free (str);
            D.26805 = 0B;
            return D.26805;
          }
          <D.26854>:
          k = k->parent;
        }
        if (k != 0B) goto <D.21543>; else goto <D.21544>;
        <D.21544>:
        monoeg_g_free (str);
        monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "icall.c", 2941);
      }
    finally
      {
        align = {CLOBBER};
      }
  }
  <D.26846>:
  <D.26739>:
  i = 0;
  goto <D.21546>;
  <D.21545>:
  D.26874 = sig->params[i];
  D.26875 = BIT_FIELD_REF <*D.26874, 32, 32>;
  D.26876 = D.26875 & 1073741824;
  if (D.26876 != 0) goto <D.26877>; else goto <D.26878>;
  <D.26877>:
  outarg_count = outarg_count + 1;
  <D.26878>:
  i = i + 1;
  <D.21546>:
  i.77 = (unsigned int) i;
  D.26880 = mono_array_length (params);
  if (i.77 < D.26880) goto <D.21545>; else goto <D.21547>;
  <D.21547>:
  D.26737 = mono_defaults.object_class;
  outarg_count.78 = (unsigned int) outarg_count;
  out_args = mono_array_new (domain, D.26737, outarg_count.78);
  {
    size_t __s1_len;
    size_t __s2_len;

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

      D.26885 = method->method;
      __s2 = D.26885->name;
      D.26886 = ".ctor";
      D.26887 = MEM[(const unsigned char *)D.26886];
      D.26888 = (int) D.26887;
      D.26889 = *__s2;
      D.26890 = (int) D.26889;
      __result = D.26888 - D.26890;
      {
        if (__s2_len != 0) goto <D.26891>; else goto <D.26892>;
        <D.26891>:
        if (__result == 0) goto <D.26893>; else goto <D.26894>;
        <D.26893>:
        D.26895 = &MEM[(void *)".ctor" + 1B];
        D.26896 = *D.26895;
        D.26897 = (int) D.26896;
        D.26898 = __s2 + 1;
        D.26899 = *D.26898;
        D.26900 = (int) D.26899;
        __result = D.26897 - D.26900;
        if (__s2_len > 1) goto <D.26901>; else goto <D.26902>;
        <D.26901>:
        if (__result == 0) goto <D.26903>; else goto <D.26904>;
        <D.26903>:
        D.26905 = &MEM[(void *)".ctor" + 2B];
        D.26906 = *D.26905;
        D.26907 = (int) D.26906;
        D.26908 = __s2 + 2;
        D.26909 = *D.26908;
        D.26910 = (int) D.26909;
        __result = D.26907 - D.26910;
        if (__s2_len > 2) goto <D.26911>; else goto <D.26912>;
        <D.26911>:
        if (__result == 0) goto <D.26913>; else goto <D.26914>;
        <D.26913>:
        D.26915 = &MEM[(void *)".ctor" + 3B];
        D.26916 = *D.26915;
        D.26917 = (int) D.26916;
        D.26918 = __s2 + 3;
        D.26919 = *D.26918;
        D.26920 = (int) D.26919;
        __result = D.26917 - D.26920;
        <D.26914>:
        <D.26912>:
        <D.26904>:
        <D.26902>:
        <D.26894>:
        <D.26892>:
      }
      D.21555 = __result;
    }
    iftmp.79 = -D.21555;
    goto <D.26921>;
    <D.26884>:
    D.26885 = method->method;
    D.26922 = D.26885->name;
    iftmp.79 = __builtin_strcmp (D.26922, ".ctor");
    <D.26921>:
    D.21556 = iftmp.79;
  }
  if (D.21556 == 0) goto <D.26923>; else goto <D.26924>;
  <D.26923>:
  D.26787 = this == 0B;
  D.26788 = (long int) D.26787;
  D.26789 = __builtin_expect (D.26788, 0);
  if (D.26789 != 0) goto <D.26925>; else goto <D.26926>;
  <D.26925>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "icall.c", 2955, "this");
  <D.26926>:
  <D.26924>:
  D.26885 = method->method;
  D.26927 = D.26885->klass;
  D.26928 = BIT_FIELD_REF <*D.26927, 32, 160>;
  D.26929 = D.26928 & 8;
  D.26930 = D.26929 != 0;
  D.26931 = (long int) D.26930;
  D.26932 = __builtin_expect (D.26931, 0);
  if (D.26932 != 0) goto <D.26933>; else goto <D.26934>;
  <D.26933>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "icall.c", 2958, "!method->method->klass->valuetype");
  <D.26934>:
  D.26885 = method->method;
  result = mono_runtime_invoke_array (D.26885, this, params, 0B);
  i = 0;
  j = 0;
  goto <D.21560>;
  <D.21559>:
  D.26874 = sig->params[i];
  D.26875 = BIT_FIELD_REF <*D.26874, 32, 32>;
  D.26876 = D.26875 & 1073741824;
  if (D.26876 != 0) goto <D.26935>; else goto <D.26936>;
  <D.26935>:
  {
    void * arg;

    i.77 = (unsigned int) i;
    D.26937 = mono_array_addr_with_size (params, 4, i.77);
    arg = MEM[(void * *)D.26937];
    {
      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.26936>:
  i = i + 1;
  <D.21560>:
  i.77 = (unsigned int) i;
  D.26939 = mono_array_length (params);
  if (i.77 < D.26939) goto <D.21559>; else goto <D.21561>;
  <D.21561>:
  mono_gc_wbarrier_generic_store (outArgs, out_args);
  D.26805 = result;
  return D.26805;
}


ves_icall_Remoting_RemotingServices_GetVirtualMethod (struct MonoReflectionType * rtype, struct MonoReflectionMethod * rmethod)
{
  _Bool D.26942;
  long int D.26943;
  long int D.26944;
  _Bool D.26949;
  long int D.26950;
  long int D.26951;
  struct MonoType * D.26956;
  unsigned int D.26959;
  unsigned int D.26960;
  unsigned char D.26962;
  struct MonoReflectionMethod * D.26964;
  short unsigned int D.26965;
  int D.26966;
  int D.26967;
  unsigned int D.26970;
  unsigned int D.26971;
  struct MonoClass * D.26976;
  int D.26978;
  unsigned int D.26979;
  unsigned int D.26980;
  short int D.26985;
  int D.26986;
  int D.26987;
  unsigned int D.26988;
  unsigned int D.26989;
  struct MonoMethod * * D.26990;
  int D.26994;
  unsigned int D.26999;
  unsigned int D.27000;
  struct MonoMethod * * D.27001;
  struct MonoDomain * D.27004;
  struct MonoClass * klass;
  struct MonoMethod * method;
  struct MonoMethod * * vtable;
  struct MonoMethod * res;

  res = 0B;
  D.26942 = rtype == 0B;
  D.26943 = (long int) D.26942;
  D.26944 = __builtin_expect (D.26943, 0);
  if (D.26944 != 0) goto <D.26945>; else goto <D.26946>;
  <D.26945>:
  {
    struct MonoException * ex;

    if (rtype != 0B) goto <D.26947>; else goto <D.26948>;
    <D.26947>:
    <D.26948>:
    ex = mono_get_exception_argument_null ("rtype");
    mono_raise_exception (ex);
  }
  <D.26946>:
  D.26949 = rmethod == 0B;
  D.26950 = (long int) D.26949;
  D.26951 = __builtin_expect (D.26950, 0);
  if (D.26951 != 0) goto <D.26952>; else goto <D.26953>;
  <D.26952>:
  {
    struct MonoException * ex;

    if (rmethod != 0B) goto <D.26954>; else goto <D.26955>;
    <D.26954>:
    <D.26955>:
    ex = mono_get_exception_argument_null ("rmethod");
    mono_raise_exception (ex);
  }
  <D.26953>:
  method = rmethod->method;
  D.26956 = rtype->type;
  klass = mono_class_from_mono_type (D.26956);
  mono_class_init_or_throw (klass);
  D.26959 = klass->flags;
  D.26960 = D.26959 & 32;
  if (D.26960 != 0) goto <D.26957>; else goto <D.26961>;
  <D.26961>:
  D.26962 = klass->byval_arg.type;
  if (D.26962 == 19) goto <D.26957>; else goto <D.26963>;
  <D.26963>:
  D.26962 = klass->byval_arg.type;
  if (D.26962 == 30) goto <D.26957>; else goto <D.26958>;
  <D.26957>:
  D.26964 = 0B;
  return D.26964;
  <D.26958>:
  D.26965 = method->flags;
  D.26966 = (int) D.26965;
  D.26967 = D.26966 & 16;
  if (D.26967 != 0) goto <D.26968>; else goto <D.26969>;
  <D.26968>:
  D.26964 = 0B;
  return D.26964;
  <D.26969>:
  D.26965 = method->flags;
  D.26970 = (unsigned int) D.26965;
  D.26971 = D.26970 & 96;
  if (D.26971 != 64) goto <D.26972>; else goto <D.26973>;
  <D.26972>:
  D.26976 = method->klass;
  if (D.26976 == klass) goto <D.26974>; else goto <D.26977>;
  <D.26977>:
  D.26976 = method->klass;
  D.26978 = mono_class_is_subclass_of (klass, D.26976, 0);
  if (D.26978 != 0) goto <D.26974>; else goto <D.26975>;
  <D.26974>:
  D.26964 = rmethod;
  return D.26964;
  <D.26975>:
  D.26964 = 0B;
  return D.26964;
  <D.26973>:
  mono_class_setup_vtable (klass);
  vtable = klass->vtable;
  D.26976 = method->klass;
  D.26979 = D.26976->flags;
  D.26980 = D.26979 & 32;
  if (D.26980 != 0) goto <D.26981>; else goto <D.26982>;
  <D.26981>:
  {
    gboolean variance_used;
    int offs;

    try
      {
        variance_used = 0;
        D.26976 = method->klass;
        offs = mono_class_interface_offset_with_variance (klass, D.26976, &variance_used);
        if (offs >= 0) goto <D.26983>; else goto <D.26984>;
        <D.26983>:
        D.26985 = method->slot;
        D.26986 = (int) D.26985;
        D.26987 = D.26986 + offs;
        D.26988 = (unsigned int) D.26987;
        D.26989 = D.26988 * 4;
        D.26990 = vtable + D.26989;
        res = *D.26990;
        <D.26984>:
      }
    finally
      {
        variance_used = {CLOBBER};
      }
  }
  goto <D.26991>;
  <D.26982>:
  D.26976 = method->klass;
  if (D.26976 != klass) goto <D.26992>; else goto <D.26993>;
  <D.26992>:
  D.26976 = method->klass;
  D.26994 = mono_class_is_subclass_of (klass, D.26976, 0);
  if (D.26994 == 0) goto <D.26995>; else goto <D.26996>;
  <D.26995>:
  D.26964 = 0B;
  return D.26964;
  <D.26996>:
  <D.26993>:
  D.26985 = method->slot;
  if (D.26985 != -1) goto <D.26997>; else goto <D.26998>;
  <D.26997>:
  D.26985 = method->slot;
  D.26999 = (unsigned int) D.26985;
  D.27000 = D.26999 * 4;
  D.27001 = vtable + D.27000;
  res = *D.27001;
  <D.26998>:
  <D.26991>:
  if (res == 0B) goto <D.27002>; else goto <D.27003>;
  <D.27002>:
  D.26964 = 0B;
  return D.26964;
  <D.27003>:
  D.27004 = mono_domain_get ();
  D.26964 = mono_method_get_object (D.27004, res, 0B);
  return D.26964;
}


ves_icall_Remoting_RealProxy_GetTransparentProxy (struct MonoObject * this, struct MonoString * class_name)
{
  struct MonoVTable * D.27006;
  struct MonoClass * D.27007;
  struct MonoRealProxy * * D.27008;
  struct MonoReflectionType * D.27009;
  struct MonoClass * D.27010;
  struct MonoObject * D.27011;
  _Bool D.27012;
  unsigned char D.27013;
  struct MonoRemoteClass * D.27014;
  struct MonoRemoteClass * D.27015;
  void * D.27016;
  struct MonoObject * D.27017;
  struct MonoDomain * domain;
  struct MonoObject * res;
  struct MonoRealProxy * rp;
  struct MonoTransparentProxy * tp;
  struct MonoType * type;
  struct MonoClass * klass;

  D.27006 = this->vtable;
  domain = D.27006->domain;
  rp = this;
  D.27007 = mono_defaults.transparent_proxy_class;
  res = mono_object_new (domain, D.27007);
  tp = res;
  D.27008 = &tp->rp;
  mono_gc_wbarrier_set_field (tp, D.27008, rp);
  D.27009 = rp->class_to_proxy;
  type = D.27009->type;
  klass = mono_class_from_mono_type (type);
  D.27010 = mono_defaults.iremotingtypeinfo_class;
  D.27011 = mono_object_isinst (this, D.27010);
  D.27012 = D.27011 != 0B;
  D.27013 = (unsigned char) D.27012;
  tp->custom_type_info = D.27013;
  D.27014 = mono_remote_class (domain, class_name, klass);
  tp->remote_class = D.27014;
  D.27015 = tp->remote_class;
  D.27016 = mono_remote_class_vtable (domain, D.27015, rp);
  res->vtable = D.27016;
  D.27017 = res;
  return D.27017;
}


ves_icall_Remoting_RealProxy_InternalGetProxyType (struct MonoTransparentProxy * tp)
{
  struct MonoReflectionType * D.27019;
  struct MonoVTable * D.27020;
  struct MonoDomain * D.27021;
  struct MonoRemoteClass * D.27022;
  struct MonoClass * D.27023;
  struct MonoType * D.27024;

  D.27020 = MEM[(struct MonoObject *)tp].vtable;
  D.27021 = D.27020->domain;
  D.27022 = tp->remote_class;
  D.27023 = D.27022->proxy_class;
  D.27024 = &D.27023->byval_arg;
  D.27019 = mono_type_get_object (D.27021, D.27024);
  return D.27019;
}


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

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


ves_icall_System_Runtime_Activation_ActivationServices_EnableProxyActivation (struct MonoReflectionType * type, MonoBoolean enable)
{
  struct MonoType * D.27028;
  struct MonoDomain * D.27029;
  _Bool D.27030;
  struct MonoClass * klass;
  struct MonoVTable * vtable;

  D.27028 = type->type;
  klass = mono_class_from_mono_type (D.27028);
  D.27029 = mono_domain_get ();
  vtable = mono_class_vtable_full (D.27029, klass, 1);
  D.27030 = enable != 0;
  vtable->remote = D.27030;
}


ves_icall_System_Runtime_Activation_ActivationServices_AllocateUninitializedClassInstance (struct MonoReflectionType * type)
{
  struct MonoVTable * D.27031;
  struct MonoType * D.27032;
  unsigned int D.27035;
  unsigned int D.27036;
  unsigned char D.27038;
  unsigned int D.27041;
  struct MonoException * D.27042;
  unsigned char D.27043;
  _Bool D.27046;
  long int D.27047;
  long int D.27048;
  struct MonoObject * D.27051;
  struct MonoClass * D.27052;
  struct MonoVTable * D.27053;
  struct MonoClass * klass;
  struct MonoDomain * domain;

  D.27031 = MEM[(struct MonoObject *)type].vtable;
  domain = D.27031->domain;
  D.27032 = type->type;
  klass = mono_class_from_mono_type (D.27032);
  mono_class_init_or_throw (klass);
  D.27035 = klass->flags;
  D.27036 = D.27035 & 32;
  if (D.27036 != 0) goto <D.27033>; else goto <D.27037>;
  <D.27037>:
  D.27038 = klass->byval_arg.type;
  if (D.27038 == 19) goto <D.27033>; else goto <D.27039>;
  <D.27039>:
  D.27038 = klass->byval_arg.type;
  if (D.27038 == 30) goto <D.27033>; else goto <D.27040>;
  <D.27040>:
  D.27035 = klass->flags;
  D.27041 = D.27035 & 128;
  if (D.27041 != 0) goto <D.27033>; else goto <D.27034>;
  <D.27033>:
  D.27042 = mono_get_exception_argument ("type", "Type cannot be instantiated");
  mono_raise_exception (D.27042);
  <D.27034>:
  D.27043 = klass->rank;
  if (D.27043 != 0) goto <D.27044>; else goto <D.27045>;
  <D.27044>:
  D.27043 = klass->rank;
  D.27046 = D.27043 != 1;
  D.27047 = (long int) D.27046;
  D.27048 = __builtin_expect (D.27047, 0);
  if (D.27048 != 0) goto <D.27049>; else goto <D.27050>;
  <D.27049>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "icall.c", 6838, "klass->rank == 1");
  <D.27050>:
  D.27052 = klass->element_class;
  D.27051 = mono_array_new (domain, D.27052, 0);
  return D.27051;
  <D.27045>:
  D.27053 = mono_class_vtable_full (domain, klass, 1);
  D.27051 = mono_object_new_alloc_specific (D.27053);
  return D.27051;
}


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

  try
    {
      D.27055 = type->type;
      klass = mono_class_from_mono_type (D.27055);
      iter = 0B;
      mono_class_init_or_throw (klass);
      goto <D.23110>;
      <D.23109>:
      prelink_method (m);
      <D.23110>:
      m = mono_class_get_methods (klass, &iter);
      if (m != 0B) goto <D.23109>; else goto <D.23111>;
      <D.23111>:
    }
  finally
    {
      iter = {CLOBBER};
    }
}


prelink_method (struct MonoMethod * method)
{
  short unsigned int D.27056;
  int D.27057;
  int D.27058;
  const char * exc_class.81;
  struct MonoImage * D.27064;
  const char * exc_arg.82;
  struct MonoException * D.27066;
  const char * exc_class;
  const char * exc_arg;

  try
    {
      D.27056 = method->flags;
      D.27057 = (int) D.27056;
      D.27058 = D.27057 & 8192;
      if (D.27058 == 0) goto <D.27059>; else goto <D.27060>;
      <D.27059>:
      return;
      <D.27060>:
      mono_lookup_pinvoke_call (method, &exc_class, &exc_arg);
      exc_class.81 = exc_class;
      if (exc_class.81 != 0B) goto <D.27062>; else goto <D.27063>;
      <D.27062>:
      D.27064 = mono_defaults.corlib;
      exc_class.81 = exc_class;
      exc_arg.82 = exc_arg;
      D.27066 = mono_exception_from_name_msg (D.27064, "System", exc_class.81, exc_arg.82);
      mono_raise_exception (D.27066);
      <D.27063>:
    }
  finally
    {
      exc_class = {CLOBBER};
      exc_arg = {CLOBBER};
    }
}


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

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


ves_icall_System_Runtime_CompilerServices_RuntimeHelpers_SufficientExecutionStack ()
{
  guint8 * stack_addr.83;
  MonoBoolean D.27074;
  int current.84;
  int stack_addr.85;
  int D.27079;
  unsigned int stack_size.86;
  sizetype D.27084;
  guint8 * D.27085;
  int D.27086;
  int D.27087;
  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.27072>; else goto <D.27073>;
      <D.27072>:
      D.27074 = 1;
      return D.27074;
      <D.27073>:
      current = &stack_addr;
      stack_addr.83 = stack_addr;
      if (current > stack_addr.83) goto <D.27075>; else goto <D.27076>;
      <D.27075>:
      current.84 = (int) current;
      stack_addr.83 = stack_addr;
      stack_addr.85 = (int) stack_addr.83;
      D.27079 = current.84 - stack_addr.85;
      if (D.27079 < min_size) goto <D.27080>; else goto <D.27081>;
      <D.27080>:
      D.27074 = 0;
      return D.27074;
      <D.27081>:
      goto <D.27082>;
      <D.27076>:
      current.84 = (int) current;
      stack_addr.83 = stack_addr;
      stack_size.86 = stack_size;
      D.27084 = -stack_size.86;
      D.27085 = stack_addr.83 + D.27084;
      D.27086 = (int) D.27085;
      D.27087 = current.84 - D.27086;
      if (D.27087 < min_size) goto <D.27088>; else goto <D.27089>;
      <D.27088>:
      D.27074 = 0;
      return D.27074;
      <D.27089>:
      <D.27082>:
      D.27074 = 1;
      return D.27074;
    }
  finally
    {
      stack_addr = {CLOBBER};
      stack_size = {CLOBBER};
    }
}


ves_icall_System_Runtime_CompilerServices_RuntimeHelpers_RunModuleConstructor (struct MonoImage * image)
{
  unsigned int D.27092;
  unsigned int D.27093;
  struct MonoDomain * D.27096;
  struct MonoVTable * D.27097;

  mono_image_check_for_module_cctor (image);
  D.27092 = BIT_FIELD_REF <*image, 32, 128>;
  D.27093 = D.27092 & 128;
  if (D.27093 != 0) goto <D.27094>; else goto <D.27095>;
  <D.27094>:
  {
    struct MonoClass * module_klass;

    module_klass = mono_class_get (image, 33554433);
    D.27096 = mono_domain_get ();
    D.27097 = mono_class_vtable_full (D.27096, module_klass, 1);
    mono_runtime_class_init (D.27097);
  }
  <D.27095>:
}


ves_icall_System_Runtime_CompilerServices_RuntimeHelpers_RunClassConstructor (struct MonoType * handle)
{
  _Bool D.27098;
  long int D.27099;
  long int D.27100;
  _Bool D.27105;
  long int D.27106;
  long int D.27107;
  struct MonoDomain * D.27112;
  struct MonoClass * klass;
  struct MonoVTable * vtable;

  D.27098 = handle == 0B;
  D.27099 = (long int) D.27098;
  D.27100 = __builtin_expect (D.27099, 0);
  if (D.27100 != 0) goto <D.27101>; else goto <D.27102>;
  <D.27101>:
  {
    struct MonoException * ex;

    if (handle != 0B) goto <D.27103>; else goto <D.27104>;
    <D.27103>:
    <D.27104>:
    ex = mono_get_exception_argument_null ("handle");
    mono_raise_exception (ex);
  }
  <D.27102>:
  klass = mono_class_from_mono_type (handle);
  D.27105 = klass == 0B;
  D.27106 = (long int) D.27105;
  D.27107 = __builtin_expect (D.27106, 0);
  if (D.27107 != 0) goto <D.27108>; else goto <D.27109>;
  <D.27108>:
  {
    struct MonoException * ex;
    char * msg;

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


ves_icall_System_Runtime_CompilerServices_RuntimeHelpers_InitializeArray (struct MonoArray * array, struct MonoClassField * field_handle)
{
  struct MonoVTable * D.27113;
  int D.27114;
  struct MonoClass * D.27115;
  struct MonoType * D.27116;
  int D.27119;
  unsigned char D.27121;
  struct MonoType * D.27122;
  short unsigned int D.27123;
  int D.27124;
  int D.27125;
  unsigned int D.27128;
  int D.27129;
  unsigned int D.27130;
  char * D.27133;
  struct MonoClass * klass;
  guint32 size;
  struct MonoType * type;
  int align;
  const char * field_data;

  try
    {
      D.27113 = array->obj.vtable;
      klass = D.27113->klass;
      D.27114 = mono_array_element_size (klass);
      size = (guint32) D.27114;
      D.27115 = klass->element_class;
      D.27116 = &D.27115->byval_arg;
      type = mono_type_get_underlying_type (D.27116);
      D.27119 = mono_type_is_reference (type);
      if (D.27119 != 0) goto <D.27117>; else goto <D.27120>;
      <D.27120>:
      D.27121 = type->type;
      if (D.27121 == 17) goto <D.27117>; else goto <D.27118>;
      <D.27117>:
      {
        struct MonoException * exc;

        exc = mono_get_exception_argument ("array", "Cannot initialize array of non-primitive type.");
        mono_raise_exception (exc);
      }
      <D.27118>:
      D.27122 = field_handle->type;
      D.27123 = D.27122->attrs;
      D.27124 = (int) D.27123;
      D.27125 = D.27124 & 256;
      if (D.27125 == 0) goto <D.27126>; else goto <D.27127>;
      <D.27126>:
      {
        struct MonoException * exc;

        exc = mono_get_exception_argument ("field_handle", "Field doesn\'t have an RVA");
        mono_raise_exception (exc);
      }
      <D.27127>:
      D.27128 = array->max_length;
      size = D.27128 * size;
      field_data = mono_field_get_data (field_handle);
      D.27122 = field_handle->type;
      D.27129 = mono_type_size (D.27122, &align);
      D.27130 = (unsigned int) D.27129;
      if (D.27130 < size) goto <D.27131>; else goto <D.27132>;
      <D.27131>:
      {
        struct MonoException * exc;

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


ves_icall_System_Runtime_CompilerServices_RuntimeHelpers_GetOffsetToStringData ()
{
  gint D.27134;

  D.27134 = 12;
  return D.27134;
}


ves_icall_System_Runtime_CompilerServices_RuntimeHelpers_GetObjectValue (struct MonoObject * obj)
{
  struct MonoVTable * D.27139;
  struct MonoClass * D.27140;
  unsigned int D.27141;
  unsigned int D.27142;
  struct MonoObject * D.27143;

  if (obj == 0B) goto <D.27136>; else goto <D.27138>;
  <D.27138>:
  D.27139 = obj->vtable;
  D.27140 = D.27139->klass;
  D.27141 = BIT_FIELD_REF <*D.27140, 32, 160>;
  D.27142 = D.27141 & 8;
  if (D.27142 == 0) goto <D.27136>; else goto <D.27137>;
  <D.27136>:
  D.27143 = obj;
  return D.27143;
  <D.27137>:
  D.27143 = mono_object_clone (obj);
  return D.27143;
}


param_info_get_type_modifiers (struct MonoReflectionParameter * param, MonoBoolean optional)
{
  struct MonoReflectionType * D.27145;
  struct MonoObject * D.27146;
  struct MonoVTable * D.27147;
  int D.27148;
  struct MonoImage * D.27154;
  struct MonoImage * D.27155;
  int D.23174;
  int iftmp.87;
  int D.23170;
  const char[13] * D.27160;
  unsigned char D.27161;
  int D.27162;
  unsigned char D.27163;
  int D.27164;
  const unsigned char * D.27169;
  unsigned char D.27170;
  int D.27171;
  const unsigned char * D.27172;
  unsigned char D.27173;
  int D.27174;
  const unsigned char * D.27179;
  unsigned char D.27180;
  int D.27181;
  const unsigned char * D.27182;
  unsigned char D.27183;
  int D.27184;
  const unsigned char * D.27189;
  unsigned char D.27190;
  int D.27191;
  const unsigned char * D.27192;
  unsigned char D.27193;
  int D.27194;
  const char * D.27196;
  struct MonoProperty * D.27198;
  _Bool D.27201;
  long int D.27202;
  long int D.27203;
  struct MonoClass * D.27206;
  struct MonoArray * D.27210;
  int D.27211;
  struct MonoType * type;
  struct MonoClass * member_class;
  struct MonoMethod * method;
  struct MonoImage * image;
  int pos;
  struct MonoMethodSignature * sig;

  D.27145 = param->ClassImpl;
  type = D.27145->type;
  D.27146 = param->MemberImpl;
  D.27147 = D.27146->vtable;
  member_class = D.27147->klass;
  method = 0B;
  D.27148 = mono_class_is_reflection_method_or_constructor (member_class);
  if (D.27148 != 0) goto <D.27149>; else goto <D.27150>;
  <D.27149>:
  {
    struct MonoReflectionMethod * rmethod;

    rmethod = param->MemberImpl;
    method = rmethod->method;
  }
  goto <D.27151>;
  <D.27150>:
  D.27154 = member_class->image;
  D.27155 = mono_defaults.corlib;
  if (D.27154 == D.27155) goto <D.27156>; else goto <D.27152>;
  <D.27156>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = member_class->name;
      D.27160 = "MonoProperty";
      D.27161 = MEM[(const unsigned char *)D.27160];
      D.27162 = (int) D.27161;
      D.27163 = *__s2;
      D.27164 = (int) D.27163;
      __result = D.27162 - D.27164;
      {
        if (__s1_len != 0) goto <D.27165>; else goto <D.27166>;
        <D.27165>:
        if (__result == 0) goto <D.27167>; else goto <D.27168>;
        <D.27167>:
        D.27169 = &MEM[(void *)"MonoProperty" + 1B];
        D.27170 = *D.27169;
        D.27171 = (int) D.27170;
        D.27172 = __s2 + 1;
        D.27173 = *D.27172;
        D.27174 = (int) D.27173;
        __result = D.27171 - D.27174;
        if (__s1_len > 1) goto <D.27175>; else goto <D.27176>;
        <D.27175>:
        if (__result == 0) goto <D.27177>; else goto <D.27178>;
        <D.27177>:
        D.27179 = &MEM[(void *)"MonoProperty" + 2B];
        D.27180 = *D.27179;
        D.27181 = (int) D.27180;
        D.27182 = __s2 + 2;
        D.27183 = *D.27182;
        D.27184 = (int) D.27183;
        __result = D.27181 - D.27184;
        if (__s1_len > 2) goto <D.27185>; else goto <D.27186>;
        <D.27185>:
        if (__result == 0) goto <D.27187>; else goto <D.27188>;
        <D.27187>:
        D.27189 = &MEM[(void *)"MonoProperty" + 3B];
        D.27190 = *D.27189;
        D.27191 = (int) D.27190;
        D.27192 = __s2 + 3;
        D.27193 = *D.27192;
        D.27194 = (int) D.27193;
        __result = D.27191 - D.27194;
        <D.27188>:
        <D.27186>:
        <D.27178>:
        <D.27176>:
        <D.27168>:
        <D.27166>:
      }
      D.23170 = __result;
    }
    iftmp.87 = D.23170;
    goto <D.27195>;
    <D.27159>:
    D.27196 = member_class->name;
    iftmp.87 = __builtin_strcmp ("MonoProperty", D.27196);
    <D.27195>:
    D.23174 = iftmp.87;
  }
  if (D.23174 == 0) goto <D.27197>; else goto <D.27152>;
  <D.27197>:
  {
    struct MonoReflectionProperty * prop;

    prop = param->MemberImpl;
    D.27198 = prop->property;
    method = D.27198->get;
    if (method == 0B) goto <D.27199>; else goto <D.27200>;
    <D.27199>:
    D.27198 = prop->property;
    method = D.27198->set;
    <D.27200>:
    D.27201 = method == 0B;
    D.27202 = (long int) D.27201;
    D.27203 = __builtin_expect (D.27202, 0);
    if (D.27203 != 0) goto <D.27204>; else goto <D.27205>;
    <D.27204>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "icall.c", 7444, "method");
    <D.27205>:
  }
  goto <D.27153>;
  <D.27152>:
  {
    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.27153>:
  <D.27151>:
  D.27206 = method->klass;
  image = D.27206->image;
  pos = param->PositionImpl;
  sig = mono_method_signature (method);
  if (pos == -1) goto <D.27207>; else goto <D.27208>;
  <D.27207>:
  type = sig->ret;
  goto <D.27209>;
  <D.27208>:
  type = sig->params[pos];
  <D.27209>:
  D.27211 = (int) optional;
  D.27210 = type_array_from_modifiers (image, type, D.27211);
  return D.27210;
}


type_array_from_modifiers (struct MonoImage * image, struct MonoType * type, int optional)
{
  <unnamed-unsigned:1> D.27217;
  <unnamed-unsigned:6> D.27219;
  int D.27220;
  struct MonoArray * D.27223;
  struct MonoDomain * D.27224;
  struct MonoClass * D.27225;
  unsigned int count.88;
  <unnamed-unsigned:31> D.27232;
  unsigned int D.27233;
  struct MonoDomain * D.27234;
  struct MonoType * D.27235;
  struct MonoReflectionType * D.27236;
  struct MonoArray * res;
  int i;
  int count;

  count = 0;
  i = 0;
  goto <D.23148>;
  <D.23147>:
  if (optional != 0) goto <D.27216>; else goto <D.27213>;
  <D.27216>:
  D.27217 = type->modifiers[i].required;
  if (D.27217 == 0) goto <D.27214>; else goto <D.27213>;
  <D.27213>:
  if (optional == 0) goto <D.27218>; else goto <D.27215>;
  <D.27218>:
  D.27217 = type->modifiers[i].required;
  if (D.27217 != 0) goto <D.27214>; else goto <D.27215>;
  <D.27214>:
  count = count + 1;
  <D.27215>:
  i = i + 1;
  <D.23148>:
  D.27219 = type->num_mods;
  D.27220 = (int) D.27219;
  if (D.27220 > i) goto <D.23147>; else goto <D.23149>;
  <D.23149>:
  if (count == 0) goto <D.27221>; else goto <D.27222>;
  <D.27221>:
  D.27223 = 0B;
  return D.27223;
  <D.27222>:
  D.27224 = mono_domain_get ();
  D.27225 = mono_defaults.systemtype_class;
  count.88 = (unsigned int) count;
  res = mono_array_new (D.27224, D.27225, count.88);
  count = 0;
  i = 0;
  goto <D.23153>;
  <D.23152>:
  if (optional != 0) goto <D.27230>; else goto <D.27227>;
  <D.27230>:
  D.27217 = type->modifiers[i].required;
  if (D.27217 == 0) goto <D.27228>; else goto <D.27227>;
  <D.27227>:
  if (optional == 0) goto <D.27231>; else goto <D.27229>;
  <D.27231>:
  D.27217 = type->modifiers[i].required;
  if (D.27217 != 0) goto <D.27228>; else goto <D.27229>;
  <D.27228>:
  {
    struct MonoClass * klass;

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

      count.88 = (unsigned int) count;
      __p = mono_array_addr_with_size (res, 4, count.88);
      D.27234 = mono_domain_get ();
      D.27235 = &klass->byval_arg;
      D.27236 = mono_type_get_object (D.27234, D.27235);
      mono_gc_wbarrier_set_arrayref (res, __p, D.27236);
    }
    count = count + 1;
  }
  <D.27229>:
  i = i + 1;
  <D.23153>:
  D.27219 = type->num_mods;
  D.27220 = (int) D.27219;
  if (D.27220 > i) goto <D.23152>; else goto <D.23154>;
  <D.23154>:
  D.27223 = res;
  return D.27223;
}


ves_icall_get_property_info (struct MonoReflectionProperty * property, struct MonoPropertyInfo * info, PInfo req_info)
{
  struct MonoVTable * D.27238;
  unsigned int D.27239;
  struct MonoReflectionType * * D.27242;
  struct MonoClass * D.27243;
  struct MonoType * D.27244;
  struct MonoReflectionType * D.27245;
  unsigned int D.27246;
  struct MonoReflectionType * * D.27249;
  struct MonoProperty * D.27250;
  struct MonoClass * D.27251;
  struct MonoType * D.27252;
  struct MonoReflectionType * D.27253;
  unsigned int D.27254;
  struct MonoString * * D.27257;
  const char * D.27258;
  struct MonoString * D.27259;
  unsigned int D.27260;
  unsigned int D.27263;
  unsigned int D.27264;
  struct MonoReflectionMethod * * D.27267;
  struct MonoObject * iftmp.89;
  struct MonoMethod * D.27269;
  unsigned int D.27273;
  struct MonoReflectionMethod * * D.27276;
  struct MonoObject * iftmp.90;
  struct MonoMethod * D.27278;
  struct MonoDomain * domain;

  D.27238 = MEM[(struct MonoObject *)property].vtable;
  domain = D.27238->domain;
  D.27239 = req_info & 8;
  if (D.27239 != 0) goto <D.27240>; else goto <D.27241>;
  <D.27240>:
  D.27242 = &info->parent;
  D.27243 = property->klass;
  D.27244 = &D.27243->byval_arg;
  D.27245 = mono_type_get_object (domain, D.27244);
  mono_gc_wbarrier_generic_store (D.27242, D.27245);
  <D.27241>:
  D.27246 = req_info & 16;
  if (D.27246 != 0) goto <D.27247>; else goto <D.27248>;
  <D.27247>:
  D.27249 = &info->declaring_type;
  D.27250 = property->property;
  D.27251 = D.27250->parent;
  D.27252 = &D.27251->byval_arg;
  D.27253 = mono_type_get_object (domain, D.27252);
  mono_gc_wbarrier_generic_store (D.27249, D.27253);
  <D.27248>:
  D.27254 = req_info & 32;
  if (D.27254 != 0) goto <D.27255>; else goto <D.27256>;
  <D.27255>:
  D.27257 = &info->name;
  D.27250 = property->property;
  D.27258 = D.27250->name;
  D.27259 = mono_string_new (domain, D.27258);
  mono_gc_wbarrier_generic_store (D.27257, D.27259);
  <D.27256>:
  D.27260 = req_info & 1;
  if (D.27260 != 0) goto <D.27261>; else goto <D.27262>;
  <D.27261>:
  D.27250 = property->property;
  D.27263 = D.27250->attrs;
  info->attrs = D.27263;
  <D.27262>:
  D.27264 = req_info & 2;
  if (D.27264 != 0) goto <D.27265>; else goto <D.27266>;
  <D.27265>:
  D.27267 = &info->get;
  D.27250 = property->property;
  D.27269 = D.27250->get;
  if (D.27269 != 0B) goto <D.27270>; else goto <D.27271>;
  <D.27270>:
  D.27250 = property->property;
  D.27269 = D.27250->get;
  D.27243 = property->klass;
  iftmp.89 = mono_method_get_object (domain, D.27269, D.27243);
  goto <D.27272>;
  <D.27271>:
  iftmp.89 = 0B;
  <D.27272>:
  mono_gc_wbarrier_generic_store (D.27267, iftmp.89);
  <D.27266>:
  D.27273 = req_info & 4;
  if (D.27273 != 0) goto <D.27274>; else goto <D.27275>;
  <D.27274>:
  D.27276 = &info->set;
  D.27250 = property->property;
  D.27278 = D.27250->set;
  if (D.27278 != 0B) goto <D.27279>; else goto <D.27280>;
  <D.27279>:
  D.27250 = property->property;
  D.27278 = D.27250->set;
  D.27243 = property->klass;
  iftmp.90 = mono_method_get_object (domain, D.27278, D.27243);
  goto <D.27281>;
  <D.27280>:
  iftmp.90 = 0B;
  <D.27281>:
  mono_gc_wbarrier_generic_store (D.27276, iftmp.90);
  <D.27275>:
}


property_info_get_default_value (struct MonoReflectionProperty * property)
{
  struct MonoVTable * D.27282;
  struct MonoClass * D.27283;
  unsigned int D.27284;
  unsigned int D.27285;
  struct MonoException * D.27288;
  <unnamed type> def_type.91;
  struct MonoObject * D.27290;
  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.27282 = MEM[(struct MonoObject *)property].vtable;
      domain = D.27282->domain;
      D.27283 = prop->parent;
      mono_class_init (D.27283);
      D.27284 = prop->attrs;
      D.27285 = D.27284 & 4096;
      if (D.27285 == 0) goto <D.27286>; else goto <D.27287>;
      <D.27286>:
      D.27288 = mono_get_exception_invalid_operation (0B);
      mono_raise_exception (D.27288);
      <D.27287>:
      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.27290 = o;
      return D.27290;
    }
  finally
    {
      blob_type = {CLOBBER};
      def_type = {CLOBBER};
    }
}


get_property_type (struct MonoProperty * prop)
{
  struct MonoMethod * D.27293;
  struct MonoType * D.27296;
  struct MonoMethod * D.27297;
  short unsigned int D.27300;
  int D.27301;
  int D.27302;
  struct MonoMethodSignature * sig;

  D.27293 = prop->get;
  if (D.27293 != 0B) goto <D.27294>; else goto <D.27295>;
  <D.27294>:
  D.27293 = prop->get;
  sig = mono_method_signature (D.27293);
  D.27296 = sig->ret;
  return D.27296;
  <D.27295>:
  D.27297 = prop->set;
  if (D.27297 != 0B) goto <D.27298>; else goto <D.27299>;
  <D.27298>:
  D.27297 = prop->set;
  sig = mono_method_signature (D.27297);
  D.27300 = sig->param_count;
  D.27301 = (int) D.27300;
  D.27302 = D.27301 + -1;
  D.27296 = sig->params[D.27302];
  return D.27296;
  <D.27299>:
  D.27296 = 0B;
  return D.27296;
}


mono_type_from_blob_type (struct MonoType * type, MonoTypeEnum blob_type, struct MonoType * real_type)
{
  unsigned char D.27304;
  struct MonoClass * D.27307;
  unsigned char D.27311;
  struct MonoClass * D.27313;
  unsigned int D.27314;
  unsigned int D.27315;
  struct MonoClass * D.27317;
  struct MonoClass * D.27318;

  D.27304 = (unsigned char) blob_type;
  type->type = D.27304;
  type->data.klass = 0B;
  if (blob_type == 18) goto <D.27305>; else goto <D.27306>;
  <D.27305>:
  D.27307 = mono_defaults.object_class;
  type->data.klass = D.27307;
  goto <D.27308>;
  <D.27306>:
  D.27311 = real_type->type;
  if (D.27311 == 17) goto <D.27312>; else goto <D.27309>;
  <D.27312>:
  D.27313 = real_type->data.klass;
  D.27314 = BIT_FIELD_REF <*D.27313, 32, 160>;
  D.27315 = D.27314 & 16;
  if (D.27315 != 0) goto <D.27316>; else goto <D.27309>;
  <D.27316>:
  type->type = 17;
  D.27317 = mono_class_from_mono_type (real_type);
  type->data.klass = D.27317;
  goto <D.27310>;
  <D.27309>:
  D.27318 = mono_class_from_mono_type (real_type);
  type->data.klass = D.27318;
  <D.27310>:
  <D.27308>:
}


property_info_get_type_modifiers (struct MonoReflectionProperty * property, MonoBoolean optional)
{
  struct MonoProperty * D.27319;
  struct MonoClass * D.27320;
  struct MonoArray * D.27323;
  int D.27324;
  struct MonoType * type;
  struct MonoImage * image;

  D.27319 = property->property;
  type = get_property_type (D.27319);
  D.27320 = property->klass;
  image = D.27320->image;
  if (type == 0B) goto <D.27321>; else goto <D.27322>;
  <D.27321>:
  D.27323 = 0B;
  return D.27323;
  <D.27322>:
  D.27324 = (int) optional;
  D.27323 = type_array_from_modifiers (image, type, D.27324);
  return D.27323;
}


ves_icall_System_MonoMethodInfo_get_retval_marshal (struct MonoMethod * method)
{
  struct MonoMethodSignature * D.27326;
  short unsigned int D.27327;
  int D.27328;
  int D.27329;
  unsigned int D.27330;
  unsigned int D.27331;
  struct MonoMarshalSpec * D.27332;
  struct MonoClass * D.27335;
  struct MonoMethodSignature * D.27336;
  short unsigned int D.27337;
  unsigned int i.92;
  unsigned int D.27339;
  struct MonoMarshalSpec * * D.27340;
  struct MonoMarshalSpec * D.27341;
  struct MonoReflectionMarshalAsAttribute * D.27344;
  struct MonoDomain * domain;
  struct MonoReflectionMarshalAsAttribute * res;
  struct MonoMarshalSpec * * mspecs;
  int i;

  domain = mono_domain_get ();
  res = 0B;
  D.27326 = mono_method_signature (method);
  D.27327 = D.27326->param_count;
  D.27328 = (int) D.27327;
  D.27329 = D.27328 + 1;
  D.27330 = (unsigned int) D.27329;
  D.27331 = D.27330 * 4;
  mspecs = monoeg_malloc (D.27331);
  mono_method_get_marshal_info (method, mspecs);
  D.27332 = *mspecs;
  if (D.27332 != 0B) goto <D.27333>; else goto <D.27334>;
  <D.27333>:
  D.27335 = method->klass;
  D.27332 = *mspecs;
  res = mono_reflection_marshal_as_attribute_from_marshal_spec (domain, D.27335, D.27332);
  <D.27334>:
  D.27336 = mono_method_signature (method);
  D.27337 = D.27336->param_count;
  i = (int) D.27337;
  goto <D.21045>;
  <D.21044>:
  i.92 = (unsigned int) i;
  D.27339 = i.92 * 4;
  D.27340 = mspecs + D.27339;
  D.27341 = *D.27340;
  if (D.27341 != 0B) goto <D.27342>; else goto <D.27343>;
  <D.27342>:
  i.92 = (unsigned int) i;
  D.27339 = i.92 * 4;
  D.27340 = mspecs + D.27339;
  D.27341 = *D.27340;
  mono_metadata_free_marshal_spec (D.27341);
  <D.27343>:
  i = i + -1;
  <D.21045>:
  if (i >= 0) goto <D.21044>; else goto <D.21046>;
  <D.21046>:
  monoeg_g_free (mspecs);
  D.27344 = res;
  return D.27344;
}


ves_icall_get_parameter_info (struct MonoMethod * method, struct MonoReflectionMethod * member)
{
  struct MonoArray * D.27346;
  struct MonoClass * iftmp.93;
  struct MonoReflectionType * D.27348;
  struct MonoType * D.27351;
  struct MonoDomain * domain;

  domain = mono_domain_get ();
  D.27348 = member->reftype;
  if (D.27348 != 0B) goto <D.27349>; else goto <D.27350>;
  <D.27349>:
  D.27348 = member->reftype;
  D.27351 = D.27348->type;
  iftmp.93 = mono_class_from_mono_type (D.27351);
  goto <D.27352>;
  <D.27350>:
  iftmp.93 = 0B;
  <D.27352>:
  D.27346 = mono_param_get_objects_internal (domain, method, iftmp.93);
  return D.27346;
}


ves_icall_get_method_info (struct MonoMethod * method, struct MonoMethodInfo * info)
{
  int D.27354;
  struct MonoReflectionType * * D.27357;
  struct MonoClass * D.27358;
  struct MonoType * D.27359;
  struct MonoReflectionType * D.27360;
  struct MonoReflectionType * * D.27361;
  struct MonoType * D.27362;
  struct MonoReflectionType * D.27363;
  short unsigned int D.27364;
  unsigned int D.27365;
  short unsigned int D.27366;
  unsigned int D.27367;
  unsigned int D.27368;
  unsigned int D.27369;
  guint32 iftmp.94;
  short int D.27373;
  unsigned int D.27382;
  <unnamed-unsigned:1> D.27383;
  int D.27384;
  int D.27385;
  <unnamed-unsigned:1> D.27386;
  int D.27387;
  int D.27388;
  int D.27389;
  unsigned int D.27390;
  unsigned int D.27391;
  struct MonoError error;
  struct MonoDomain * domain;
  struct MonoMethodSignature * sig;

  try
    {
      domain = mono_domain_get ();
      sig = mono_method_signature_checked (method, &error);
      D.27354 = mono_error_ok (&error);
      if (D.27354 == 0) goto <D.27355>; else goto <D.27356>;
      <D.27355>:
      mono_error_raise_exception (&error);
      <D.27356>:
      D.27357 = &info->parent;
      D.27358 = method->klass;
      D.27359 = &D.27358->byval_arg;
      D.27360 = mono_type_get_object (domain, D.27359);
      mono_gc_wbarrier_generic_store (D.27357, D.27360);
      D.27361 = &info->ret;
      D.27362 = sig->ret;
      D.27363 = mono_type_get_object (domain, D.27362);
      mono_gc_wbarrier_generic_store (D.27361, D.27363);
      D.27364 = method->flags;
      D.27365 = (unsigned int) D.27364;
      info->attrs = D.27365;
      D.27366 = method->iflags;
      D.27367 = (unsigned int) D.27366;
      info->implattrs = D.27367;
      D.27368 = BIT_FIELD_REF <*sig, 32, 64>;
      D.27369 = D.27368 & 4128768;
      if (D.27369 == 0) goto <D.27370>; else goto <D.27371>;
      <D.27370>:
      D.27373 = sig->sentinelpos;
      if (D.27373 >= 0) goto <D.27374>; else goto <D.27375>;
      <D.27374>:
      iftmp.94 = 2;
      goto <D.27376>;
      <D.27375>:
      iftmp.94 = 1;
      <D.27376>:
      info->callconv = iftmp.94;
      goto <D.27377>;
      <D.27371>:
      D.27368 = BIT_FIELD_REF <*sig, 32, 64>;
      D.27369 = D.27368 & 4128768;
      if (D.27369 == 327680) goto <D.27378>; else goto <D.27381>;
      <D.27381>:
      D.27373 = sig->sentinelpos;
      if (D.27373 >= 0) goto <D.27378>; else goto <D.27379>;
      <D.27378>:
      info->callconv = 2;
      goto <D.27380>;
      <D.27379>:
      info->callconv = 1;
      <D.27380>:
      <D.27377>:
      D.27382 = info->callconv;
      D.27383 = sig->hasthis;
      D.27384 = (int) D.27383;
      D.27385 = D.27384 << 5;
      D.27386 = sig->explicit_this;
      D.27387 = (int) D.27386;
      D.27388 = D.27387 << 6;
      D.27389 = D.27385 | D.27388;
      D.27390 = (unsigned int) D.27389;
      D.27391 = D.27382 | D.27390;
      info->callconv = D.27391;
    }
  finally
    {
      error = {CLOBBER};
    }
}


vell_icall_get_method_attributes (struct MonoMethod * method)
{
  int D.27392;
  short unsigned int D.27393;

  D.27393 = method->flags;
  D.27392 = (int) D.27393;
  return D.27392;
}


ves_icall_MonoMethod_get_name (struct MonoReflectionMethod * m)
{
  struct MonoString * * D.27395;
  struct MonoVTable * D.27396;
  struct MonoDomain * D.27397;
  const char * D.27398;
  struct MonoString * D.27399;
  struct MonoString * D.27400;
  struct MonoMethod * method;

  method = m->method;
  D.27395 = &m->name;
  D.27396 = MEM[(struct MonoObject *)m].vtable;
  D.27397 = D.27396->domain;
  D.27398 = method->name;
  D.27399 = mono_string_new (D.27397, D.27398);
  mono_gc_wbarrier_set_field (m, D.27395, D.27399);
  D.27400 = m->name;
  return D.27400;
}


ves_icall_MonoMethod_get_base_method (struct MonoReflectionMethod * m, gboolean definition)
{
  struct MonoClass * D.27402;
  struct MonoReflectionMethod * D.27405;
  short unsigned int D.27408;
  int D.27409;
  int D.27410;
  unsigned int D.27412;
  unsigned int D.27413;
  unsigned char D.27415;
  int D.27418;
  struct MonoGenericClass * D.27421;
  int D.27426;
  int D.27433;
  struct MonoMethod * * D.27436;
  unsigned int slot.95;
  unsigned int D.27438;
  struct MonoMethod * * D.27439;
  short int D.27442;
  int D.27443;
  struct MonoDomain * D.27447;
  struct MonoClass * klass;
  struct MonoClass * parent;
  struct MonoMethod * method;
  struct MonoMethod * result;
  int slot;

  method = m->method;
  result = 0B;
  D.27402 = method->klass;
  if (D.27402 == 0B) goto <D.27403>; else goto <D.27404>;
  <D.27403>:
  D.27405 = m;
  return D.27405;
  <D.27404>:
  D.27408 = method->flags;
  D.27409 = (int) D.27408;
  D.27410 = D.27409 & 64;
  if (D.27410 == 0) goto <D.27406>; else goto <D.27411>;
  <D.27411>:
  D.27402 = method->klass;
  D.27412 = D.27402->flags;
  D.27413 = D.27412 & 32;
  if (D.27413 != 0) goto <D.27406>; else goto <D.27414>;
  <D.27414>:
  D.27402 = method->klass;
  D.27415 = D.27402->byval_arg.type;
  if (D.27415 == 19) goto <D.27406>; else goto <D.27416>;
  <D.27416>:
  D.27402 = method->klass;
  D.27415 = D.27402->byval_arg.type;
  if (D.27415 == 30) goto <D.27406>; else goto <D.27417>;
  <D.27417>:
  D.27408 = method->flags;
  D.27409 = (int) D.27408;
  D.27418 = D.27409 & 256;
  if (D.27418 != 0) goto <D.27406>; else goto <D.27407>;
  <D.27406>:
  D.27405 = m;
  return D.27405;
  <D.27407>:
  slot = mono_method_get_vtable_slot (method);
  if (slot == -1) goto <D.27419>; else goto <D.27420>;
  <D.27419>:
  D.27405 = m;
  return D.27405;
  <D.27420>:
  klass = method->klass;
  D.27421 = klass->generic_class;
  if (D.27421 != 0B) goto <D.27422>; else goto <D.27423>;
  <D.27422>:
  D.27421 = klass->generic_class;
  klass = D.27421->container_class;
  <D.27423>:
  if (definition != 0) goto <D.27424>; else goto <D.27425>;
  <D.27424>:
  parent = klass->parent;
  goto <D.23049>;
  <D.23048>:
  mono_class_setup_vtable (parent);
  D.27426 = parent->vtable_size;
  if (D.27426 <= slot) goto <D.23047>; else goto <D.27427>;
  <D.27427>:
  klass = parent;
  parent = parent->parent;
  <D.23049>:
  if (parent != 0B) goto <D.23048>; else goto <D.23047>;
  <D.23047>:
  goto <D.27428>;
  <D.27425>:
  klass = klass->parent;
  if (klass == 0B) goto <D.27429>; else goto <D.27430>;
  <D.27429>:
  D.27405 = m;
  return D.27405;
  <D.27430>:
  <D.27428>:
  D.27402 = method->klass;
  if (D.27402 == klass) goto <D.27431>; else goto <D.27432>;
  <D.27431>:
  D.27405 = m;
  return D.27405;
  <D.27432>:
  D.27433 = klass->vtable_size;
  if (D.27433 <= slot) goto <D.27434>; else goto <D.27435>;
  <D.27434>:
  D.27405 = m;
  return D.27405;
  <D.27435>:
  mono_class_setup_vtable (klass);
  D.27436 = klass->vtable;
  slot.95 = (unsigned int) slot;
  D.27438 = slot.95 * 4;
  D.27439 = D.27436 + D.27438;
  result = *D.27439;
  if (result == 0B) goto <D.27440>; else goto <D.27441>;
  <D.27440>:
  {
    void * iter;

    try
      {
        iter = 0B;
        goto <D.23053>;
        <D.23052>:
        D.27442 = result->slot;
        D.27443 = (int) D.27442;
        if (D.27443 == slot) goto <D.23051>; else goto <D.27444>;
        <D.27444>:
        <D.23053>:
        result = mono_class_get_methods (klass, &iter);
        if (result != 0B) goto <D.23052>; else goto <D.23051>;
        <D.23051>:
      }
    finally
      {
        iter = {CLOBBER};
      }
  }
  <D.27441>:
  if (result == 0B) goto <D.27445>; else goto <D.27446>;
  <D.27445>:
  D.27405 = m;
  return D.27405;
  <D.27446>:
  D.27447 = mono_domain_get ();
  D.27405 = mono_method_get_object (D.27447, result, 0B);
  return D.27405;
}


ves_icall_MonoMethod_get_IsGenericMethodDefinition (struct MonoReflectionMethod * method)
{
  gboolean D.27449;
  struct MonoMethod * D.27450;
  <unnamed-unsigned:1> D.27451;

  D.27450 = method->method;
  D.27451 = D.27450->is_generic;
  D.27449 = (gboolean) D.27451;
  return D.27449;
}


ves_icall_MonoMethod_get_IsGenericMethod (struct MonoReflectionMethod * method)
{
  gboolean D.27453;
  struct MonoMethod * D.27454;
  struct MonoMethodSignature * D.27455;
  short unsigned int D.27456;
  _Bool D.27457;

  D.27454 = method->method;
  D.27455 = mono_method_signature (D.27454);
  D.27456 = D.27455->generic_param_count;
  D.27457 = D.27456 != 0;
  D.27453 = (gboolean) D.27457;
  return D.27453;
}


ves_icall_MonoMethod_GetGenericArguments (struct MonoReflectionMethod * method)
{
  struct MonoVTable * D.27459;
  struct MonoMethod * D.27460;
  unsigned int D.27461;
  unsigned int D.27462;
  struct MonoGenericContext * D.27465;
  <unnamed-unsigned:22> D.27468;
  struct MonoClass * D.27469;
  unsigned int count.96;
  unsigned int i.97;
  struct MonoType * D.27472;
  struct MonoReflectionType * D.27473;
  struct MonoArray * D.27474;
  struct MonoMethodSignature * D.27475;
  short unsigned int D.27476;
  struct MonoGenericParamFull * D.27477;
  unsigned int i.98;
  unsigned int D.27479;
  struct MonoClass * D.27480;
  struct MonoImage * D.27481;
  struct MonoType * D.27482;
  struct MonoReflectionType * D.27483;
  struct MonoArray * res;
  struct MonoDomain * domain;
  int count;
  int i;

  D.27459 = MEM[(struct MonoObject *)method].vtable;
  domain = D.27459->domain;
  D.27460 = method->method;
  D.27461 = BIT_FIELD_REF <*D.27460, 32, 160>;
  D.27462 = D.27461 & 4096;
  if (D.27462 != 0) goto <D.27463>; else goto <D.27464>;
  <D.27463>:
  {
    struct MonoGenericInst * inst;

    D.27460 = method->method;
    D.27465 = mono_method_get_context (D.27460);
    inst = D.27465->method_inst;
    if (inst != 0B) goto <D.27466>; else goto <D.27467>;
    <D.27466>:
    D.27468 = inst->type_argc;
    count = (int) D.27468;
    D.27469 = mono_defaults.systemtype_class;
    count.96 = (unsigned int) count;
    res = mono_array_new (domain, D.27469, count.96);
    i = 0;
    goto <D.21437>;
    <D.21436>:
    {
      void * * __p;

      i.97 = (unsigned int) i;
      __p = mono_array_addr_with_size (res, 4, i.97);
      D.27472 = inst->type_argv[i];
      D.27473 = mono_type_get_object (domain, D.27472);
      mono_gc_wbarrier_set_arrayref (res, __p, D.27473);
    }
    i = i + 1;
    <D.21437>:
    if (i < count) goto <D.21436>; else goto <D.21438>;
    <D.21438>:
    D.27474 = res;
    return D.27474;
    <D.27467>:
  }
  <D.27464>:
  D.27460 = method->method;
  D.27475 = mono_method_signature (D.27460);
  D.27476 = D.27475->generic_param_count;
  count = (int) D.27476;
  D.27469 = mono_defaults.systemtype_class;
  count.96 = (unsigned int) count;
  res = mono_array_new (domain, D.27469, count.96);
  i = 0;
  goto <D.21444>;
  <D.21443>:
  {
    struct MonoGenericContainer * container;
    struct MonoGenericParam * param;
    struct MonoClass * pklass;

    D.27460 = method->method;
    container = mono_method_get_generic_container (D.27460);
    D.27477 = container->type_params;
    i.98 = (unsigned int) i;
    D.27479 = i.98 * 32;
    param = D.27477 + D.27479;
    D.27460 = method->method;
    D.27480 = D.27460->klass;
    D.27481 = D.27480->image;
    pklass = mono_class_from_generic_parameter (param, D.27481, 1);
    {
      void * * __p;

      i.97 = (unsigned int) i;
      __p = mono_array_addr_with_size (res, 4, i.97);
      D.27482 = &pklass->byval_arg;
      D.27483 = mono_type_get_object (domain, D.27482);
      mono_gc_wbarrier_set_arrayref (res, __p, D.27483);
    }
  }
  i = i + 1;
  <D.21444>:
  if (i < count) goto <D.21443>; else goto <D.21445>;
  <D.21445>:
  D.27474 = res;
  return D.27474;
}


ves_icall_MonoMethod_GetDllImportAttribute (struct MonoMethod * method)
{
  struct MonoClass * D.27485;
  short unsigned int D.27486;
  int D.27487;
  int D.27488;
  struct MonoReflectionDllImportAttribute * D.27491;
  struct MonoClass * DllImportAttributeClass.99;
  struct MonoImage * D.27495;
  struct MonoClass * DllImportAttributeClass.100;
  _Bool D.27497;
  long int D.27498;
  long int D.27499;
  struct MonoImage * D.27502;
  unsigned int D.27503;
  unsigned int D.27504;
  struct GHashTable * D.27507;
  struct MonoException * D.27513;
  short unsigned int D.27515;
  int D.27518;
  int D.27519;
  unsigned int D.27520;
  short unsigned int D.27521;
  unsigned int D.27522;
  unsigned int D.27523;
  unsigned int D.27524;
  int D.27525;
  short unsigned int D.27526;
  struct MonoString * * D.27527;
  struct MonoString * D.27528;
  struct MonoString * * D.27529;
  struct MonoString * D.27530;
  unsigned int D.27531;
  unsigned int D.27532;
  int D.27533;
  unsigned int D.27534;
  unsigned int D.27535;
  unsigned int D.27536;
  int D.27537;
  int D.27538;
  unsigned int D.27541;
  _Bool D.27542;
  unsigned char D.27543;
  unsigned int D.27544;
  _Bool D.27545;
  unsigned char D.27546;
  unsigned int D.27547;
  _Bool D.27548;
  unsigned char D.27549;
  unsigned int D.27550;
  _Bool D.27551;
  unsigned char D.27552;
  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.27485 = method->klass;
      image = D.27485->image;
      piinfo = method;
      tables = &image->tables;
      im = tables + 336;
      mr = tables + 312;
      import = 0B;
      scope = 0B;
      D.27486 = method->flags;
      D.27487 = (int) D.27486;
      D.27488 = D.27487 & 8192;
      if (D.27488 == 0) goto <D.27489>; else goto <D.27490>;
      <D.27489>:
      D.27491 = 0B;
      return D.27491;
      <D.27490>:
      DllImportAttributeClass.99 = DllImportAttributeClass;
      if (DllImportAttributeClass.99 == 0B) goto <D.27493>; else goto <D.27494>;
      <D.27493>:
      D.27495 = mono_defaults.corlib;
      DllImportAttributeClass.100 = mono_class_from_name (D.27495, "System.Runtime.InteropServices", "DllImportAttribute");
      DllImportAttributeClass = DllImportAttributeClass.100;
      DllImportAttributeClass.99 = DllImportAttributeClass;
      D.27497 = DllImportAttributeClass.99 == 0B;
      D.27498 = (long int) D.27497;
      D.27499 = __builtin_expect (D.27498, 0);
      if (D.27499 != 0) goto <D.27500>; else goto <D.27501>;
      <D.27500>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "icall.c", 2598, "DllImportAttributeClass");
      <D.27501>:
      <D.27494>:
      D.27485 = method->klass;
      D.27502 = D.27485->image;
      D.27503 = BIT_FIELD_REF <*D.27502, 32, 128>;
      D.27504 = D.27503 & 8;
      if (D.27504 != 0) goto <D.27505>; else goto <D.27506>;
      <D.27505>:
      {
        struct MonoReflectionMethodAux * method_aux;

        D.27485 = method->klass;
        D.27502 = D.27485->image;
        D.27507 = MEM[(struct MonoDynamicImage *)D.27502].method_aux_hash;
        method_aux = monoeg_g_hash_table_lookup (D.27507, method);
        if (method_aux != 0B) goto <D.27508>; else goto <D.27509>;
        <D.27508>:
        import = method_aux->dllentry;
        scope = method_aux->dll;
        <D.27509>:
        if (import == 0B) goto <D.27510>; else goto <D.27512>;
        <D.27512>:
        if (scope == 0B) goto <D.27510>; else goto <D.27511>;
        <D.27510>:
        D.27513 = mono_get_exception_argument ("method", "System.Reflection.Emit method with invalid pinvoke information");
        mono_raise_exception (D.27513);
        D.27491 = 0B;
        return D.27491;
        <D.27511>:
      }
      goto <D.27514>;
      <D.27506>:
      D.27515 = piinfo->implmap_idx;
      if (D.27515 != 0) goto <D.27516>; else goto <D.27517>;
      <D.27516>:
      D.27515 = piinfo->implmap_idx;
      D.27518 = (int) D.27515;
      D.27519 = D.27518 + -1;
      mono_metadata_decode_row (im, D.27519, &im_cols, 4);
      D.27520 = im_cols[0];
      D.27521 = (short unsigned int) D.27520;
      piinfo->piflags = D.27521;
      D.27522 = im_cols[2];
      import = mono_metadata_string_heap (image, D.27522);
      D.27523 = im_cols[3];
      D.27524 = D.27523 + 4294967295;
      D.27525 = (int) D.27524;
      scope_token = mono_metadata_decode_row_col (mr, D.27525, 0);
      scope = mono_metadata_string_heap (image, scope_token);
      <D.27517>:
      <D.27514>:
      D.27526 = piinfo->piflags;
      flags = (guint32) D.27526;
      DllImportAttributeClass.99 = DllImportAttributeClass;
      attr = mono_object_new (domain, DllImportAttributeClass.99);
      D.27527 = &attr->dll;
      D.27528 = mono_string_new (domain, scope);
      mono_gc_wbarrier_set_field (attr, D.27527, D.27528);
      D.27529 = &attr->entry_point;
      D.27530 = mono_string_new (domain, import);
      mono_gc_wbarrier_set_field (attr, D.27529, D.27530);
      D.27531 = flags & 1792;
      D.27532 = D.27531 >> 8;
      D.27533 = (int) D.27532;
      attr->call_conv = D.27533;
      D.27534 = flags & 6;
      D.27535 = D.27534 >> 1;
      D.27536 = D.27535 + 1;
      D.27537 = (int) D.27536;
      attr->charset = D.27537;
      D.27538 = attr->charset;
      if (D.27538 == 1) goto <D.27539>; else goto <D.27540>;
      <D.27539>:
      attr->charset = 2;
      <D.27540>:
      D.27541 = flags & 1;
      D.27542 = D.27541 != 0;
      D.27543 = (unsigned char) D.27542;
      attr->exact_spelling = D.27543;
      D.27544 = flags & 64;
      D.27545 = D.27544 != 0;
      D.27546 = (unsigned char) D.27545;
      attr->set_last_error = D.27546;
      D.27547 = flags & 48;
      D.27548 = D.27547 == 16;
      D.27549 = (unsigned char) D.27548;
      attr->best_fit_mapping = D.27549;
      D.27550 = flags & 12288;
      D.27551 = D.27550 == 4096;
      D.27552 = (unsigned char) D.27551;
      attr->throw_on_unmappable = D.27552;
      attr->preserve_sig = 0;
      D.27491 = attr;
      return D.27491;
    }
  finally
    {
      im_cols = {CLOBBER};
    }
}


ves_icall_MonoGenericMethod_get_ReflectedType (struct MonoReflectionGenericMethod * rmethod)
{
  struct MonoReflectionType * D.27555;
  struct MonoVTable * D.27556;
  struct MonoDomain * D.27557;
  struct MonoClass * D.27558;
  struct MonoType * D.27559;
  struct MonoMethod * method;

  method = rmethod->method.method;
  D.27556 = MEM[(struct MonoObject *)rmethod].vtable;
  D.27557 = D.27556->domain;
  D.27558 = method->klass;
  D.27559 = &D.27558->byval_arg;
  D.27555 = mono_type_get_object (D.27557, D.27559);
  return D.27555;
}


ves_icall_MonoField_SetValueInternal (struct MonoReflectionField * field, struct MonoObject * obj, struct MonoObject * value)
{
  struct MonoClass * D.27561;
  struct MonoImage * D.27562;
  struct MonoAssembly * D.27563;
  int D.27564;
  struct MonoException * D.27567;
  <unnamed type> D.27568;
  int D.27571;
  unsigned int D.27574;
  unsigned int D.27575;
  unsigned char D.27578;
  int D.27579;
  struct MonoGenericInst * D.27582;
  unsigned int D.27583;
  unsigned int D.27584;
  _Bool D.27585;
  long int D.27586;
  long int D.27587;
  struct MonoClass * D.27590;
  int D.27591;
  struct MonoDomain * D.27594;
  void * D.27595;
  struct MonoClass * D.27597;
  unsigned int D.27598;
  unsigned int D.27599;
  short unsigned int D.27604;
  int D.27605;
  int D.27606;
  struct MonoVTable * D.27609;
  struct MonoDomain * D.27610;
  struct MonoClass * D.27611;
  unsigned int D.27612;
  unsigned int D.27613;
  struct MonoError error;
  struct MonoClassField * cf;
  struct MonoType * type;
  gchar * v;

  try
    {
      cf = field->field;
      D.27561 = field->klass;
      D.27562 = D.27561->image;
      D.27563 = D.27562->assembly;
      D.27564 = D.27563->ref_only;
      if (D.27564 != 0) goto <D.27565>; else goto <D.27566>;
      <D.27565>:
      D.27567 = 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.27567);
      <D.27566>:
      D.27568 = mono_security_get_mode ();
      if (D.27568 == 1) goto <D.27569>; else goto <D.27570>;
      <D.27569>:
      mono_security_core_clr_ensure_reflection_access_field (cf);
      <D.27570>:
      type = mono_field_get_type_checked (cf, &error);
      D.27571 = mono_error_ok (&error);
      if (D.27571 == 0) goto <D.27572>; else goto <D.27573>;
      <D.27572>:
      mono_error_raise_exception (&error);
      <D.27573>:
      v = value;
      D.27574 = BIT_FIELD_REF <*type, 32, 32>;
      D.27575 = D.27574 & 1073741824;
      if (D.27575 == 0) goto <D.27576>; else goto <D.27577>;
      <D.27576>:
      D.27578 = type->type;
      D.27579 = (int) D.27578;
      switch (D.27579) <default: <D.21098>, case 2: <D.21074>, case 3: <D.21077>, case 4: <D.21073>, case 5: <D.21072>, case 6: <D.21076>, case 7: <D.21075>, case 8: <D.21081>, case 9: <D.21080>, case 10: <D.21084>, case 11: <D.21083>, case 12: <D.21082>, case 13: <D.21085>, case 14: <D.21089>, case 15: <D.21087>, case 17: <D.21086>, case 18: <D.21091>, case 20: <D.21092>, case 21: <D.21094>, case 24: <D.21079>, case 25: <D.21078>, case 28: <D.21090>, case 29: <D.21093>>
      <D.21072>:
      <D.21073>:
      <D.21074>:
      <D.21075>:
      <D.21076>:
      <D.21077>:
      <D.21078>:
      <D.21079>:
      <D.21080>:
      <D.21081>:
      <D.21082>:
      <D.21083>:
      <D.21084>:
      <D.21085>:
      <D.21086>:
      <D.21087>:
      if (v != 0B) goto <D.27580>; else goto <D.27581>;
      <D.27580>:
      v = v + 8;
      <D.27581>:
      goto <D.21088>;
      <D.21089>:
      <D.21090>:
      <D.21091>:
      <D.21092>:
      <D.21093>:
      goto <D.21088>;
      <D.21094>:
      {
        struct MonoGenericClass * gclass;

        gclass = type->data.generic_class;
        D.27582 = gclass->context.class_inst;
        D.27583 = BIT_FIELD_REF <*D.27582, 32, 32>;
        D.27584 = D.27583 & 4194304;
        D.27585 = D.27584 != 0;
        D.27586 = (long int) D.27585;
        D.27587 = __builtin_expect (D.27586, 0);
        if (D.27587 != 0) goto <D.27588>; else goto <D.27589>;
        <D.27588>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "icall.c", 1825, "!gclass->context.class_inst->is_open");
        <D.27589>:
        D.27590 = mono_class_from_mono_type (type);
        D.27591 = mono_class_is_nullable (D.27590);
        if (D.27591 != 0) goto <D.27592>; else goto <D.27593>;
        <D.27592>:
        {
          struct MonoClass * nklass;
          struct MonoObject * nullable;

          nklass = mono_class_from_mono_type (type);
          D.27594 = mono_domain_get ();
          nullable = mono_object_new (D.27594, nklass);
          D.27595 = mono_object_unbox (nullable);
          mono_nullable_init (D.27595, value, nklass);
          v = mono_object_unbox (nullable);
        }
        goto <D.27596>;
        <D.27593>:
        D.27597 = gclass->container_class;
        D.27598 = BIT_FIELD_REF <*D.27597, 32, 160>;
        D.27599 = D.27598 & 8;
        if (D.27599 != 0) goto <D.27600>; else goto <D.27601>;
        <D.27600>:
        if (v != 0B) goto <D.27602>; else goto <D.27603>;
        <D.27602>:
        v = v + 8;
        <D.27603>:
        <D.27601>:
        <D.27596>:
        goto <D.21088>;
      }
      <D.21098>:
      D.27578 = type->type;
      D.27579 = (int) D.27578;
      monoeg_g_log (0B, 4, "type 0x%x not handled in ves_icall_FieldInfo_SetValueInternal", D.27579);
      <D.21099>:
      goto <D.21099>;
      return;
      <D.21088>:
      <D.27577>:
      D.27604 = type->attrs;
      D.27605 = (int) D.27604;
      D.27606 = D.27605 & 16;
      if (D.27606 != 0) goto <D.27607>; else goto <D.27608>;
      <D.27607>:
      {
        struct MonoVTable * vtable;

        D.27609 = MEM[(struct MonoObject *)field].vtable;
        D.27610 = D.27609->domain;
        D.27611 = cf->parent;
        vtable = mono_class_vtable_full (D.27610, D.27611, 1);
        D.27612 = BIT_FIELD_REF <*vtable, 32, 160>;
        D.27613 = D.27612 & 33554432;
        if (D.27613 == 0) goto <D.27614>; else goto <D.27615>;
        <D.27614>:
        mono_runtime_class_init (vtable);
        <D.27615>:
        mono_field_static_set_value (vtable, cf, v);
      }
      goto <D.27616>;
      <D.27608>:
      mono_field_set_value (obj, cf, v);
      <D.27616>:
    }
  finally
    {
      error = {CLOBBER};
    }
}


ves_icall_MonoField_ResolveType (struct MonoReflectionField * ref_field)
{
  int D.27618;
  struct MonoReflectionType * D.27621;
  struct MonoVTable * D.27622;
  struct MonoDomain * D.27623;
  struct MonoError error;
  struct MonoClassField * field;
  struct MonoType * type;

  try
    {
      field = ref_field->field;
      type = mono_field_get_type_checked (field, &error);
      D.27618 = mono_error_ok (&error);
      if (D.27618 == 0) goto <D.27619>; else goto <D.27620>;
      <D.27619>:
      mono_error_raise_exception (&error);
      <D.27620>:
      D.27622 = MEM[(struct MonoObject *)ref_field].vtable;
      D.27623 = D.27622->domain;
      D.27621 = mono_type_get_object (D.27623, type);
      return D.27621;
    }
  finally
    {
      error = {CLOBBER};
    }
}


ves_icall_MonoField_GetValueInternal (struct MonoReflectionField * field, struct MonoObject * obj)
{
  struct MonoVTable * D.27626;
  struct MonoImage * D.27627;
  struct MonoAssembly * D.27628;
  int D.27629;
  struct MonoException * D.27632;
  <unnamed type> D.27633;
  struct MonoObject * D.27636;
  struct MonoClass * fklass;
  struct MonoClassField * cf;
  struct MonoDomain * domain;

  fklass = field->klass;
  cf = field->field;
  D.27626 = MEM[(struct MonoObject *)field].vtable;
  domain = D.27626->domain;
  D.27627 = fklass->image;
  D.27628 = D.27627->assembly;
  D.27629 = D.27628->ref_only;
  if (D.27629 != 0) goto <D.27630>; else goto <D.27631>;
  <D.27630>:
  D.27632 = 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.27632);
  <D.27631>:
  D.27633 = mono_security_get_mode ();
  if (D.27633 == 1) goto <D.27634>; else goto <D.27635>;
  <D.27634>:
  mono_security_core_clr_ensure_reflection_access_field (cf);
  <D.27635>:
  D.27636 = mono_field_get_value_object (domain, cf, obj);
  return D.27636;
}


ves_icall_MonoField_GetRawConstantValue (struct MonoReflectionField * this)
{
  struct MonoVTable * D.27638;
  struct MonoClass * D.27639;
  int D.27640;
  short unsigned int D.27643;
  signed short D.27644;
  struct MonoException * D.27647;
  struct MonoImage * D.27648;
  unsigned int D.27649;
  unsigned int D.27650;
  struct MonoException * D.27655;
  <unnamed type> def_type.101;
  unsigned char D.27657;
  struct MonoObject * o.102;
  struct MonoObject * o.103;
  struct MonoObject * D.27660;
  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.27638 = MEM[(struct MonoObject *)this].vtable;
      domain = D.27638->domain;
      D.27639 = field->parent;
      mono_class_init (D.27639);
      t = mono_field_get_type_checked (field, &error);
      D.27640 = mono_error_ok (&error);
      if (D.27640 == 0) goto <D.27641>; else goto <D.27642>;
      <D.27641>:
      mono_error_raise_exception (&error);
      <D.27642>:
      D.27643 = t->attrs;
      D.27644 = (signed short) D.27643;
      if (D.27644 >= 0) goto <D.27645>; else goto <D.27646>;
      <D.27645>:
      D.27647 = mono_get_exception_invalid_operation (0B);
      mono_raise_exception (D.27647);
      <D.27646>:
      D.27639 = field->parent;
      D.27648 = D.27639->image;
      D.27649 = BIT_FIELD_REF <*D.27648, 32, 128>;
      D.27650 = D.27649 & 8;
      if (D.27650 != 0) goto <D.27651>; else goto <D.27652>;
      <D.27651>:
      monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "icall.c", 1890);
      <D.27652>:
      def_value = mono_class_get_field_default_value (field, &def_type);
      if (def_value == 0B) goto <D.27653>; else goto <D.27654>;
      <D.27653>:
      D.27655 = mono_get_exception_invalid_operation (0B);
      mono_raise_exception (D.27655);
      <D.27654>:
      def_type.101 = def_type;
      switch (def_type.101) <default: <D.21131>, case 2: <D.21115>, case 3: <D.21118>, case 4: <D.21114>, case 5: <D.21113>, case 6: <D.21117>, case 7: <D.21116>, case 8: <D.21122>, case 9: <D.21121>, case 10: <D.21125>, case 11: <D.21124>, case 12: <D.21123>, case 13: <D.21126>, case 14: <D.21129>, case 18: <D.21130>, case 24: <D.21120>, case 25: <D.21119>>
      <D.21113>:
      <D.21114>:
      <D.21115>:
      <D.21116>:
      <D.21117>:
      <D.21118>:
      <D.21119>:
      <D.21120>:
      <D.21121>:
      <D.21122>:
      <D.21123>:
      <D.21124>:
      <D.21125>:
      <D.21126>:
      {
        struct MonoType * t;

        t = monoeg_malloc0 (8);
        def_type.101 = def_type;
        D.27657 = (unsigned char) def_type.101;
        t->type = D.27657;
        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.21128>;
      }
      <D.21129>:
      <D.21130>:
      def_type.101 = def_type;
      mono_get_constant_value_from_blob (domain, def_type.101, def_value, &o);
      goto <D.21128>;
      <D.21131>:
      monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "icall.c", 1930);
      <D.21128>:
      D.27660 = o;
      return D.27660;
    }
  finally
    {
      o = {CLOBBER};
      def_type = {CLOBBER};
      error = {CLOBBER};
    }
}


ves_icall_MonoField_GetParentType (struct MonoReflectionField * field, MonoBoolean declaring)
{
  struct MonoClass * iftmp.104;
  struct MonoClassField * D.27666;
  struct MonoReflectionType * D.27668;
  struct MonoVTable * D.27669;
  struct MonoDomain * D.27670;
  struct MonoType * D.27671;
  struct MonoClass * parent;

  if (declaring != 0) goto <D.27664>; else goto <D.27665>;
  <D.27664>:
  D.27666 = field->field;
  iftmp.104 = D.27666->parent;
  goto <D.27667>;
  <D.27665>:
  iftmp.104 = field->klass;
  <D.27667>:
  parent = iftmp.104;
  D.27669 = MEM[(struct MonoObject *)field].vtable;
  D.27670 = D.27669->domain;
  D.27671 = &parent->byval_arg;
  D.27668 = mono_type_get_object (D.27670, D.27671);
  return D.27668;
}


ves_icall_MonoField_GetFieldOffset (struct MonoReflectionField * field)
{
  struct MonoClassField * D.27673;
  unsigned int D.27674;
  unsigned int D.27675;
  gint32 D.27678;
  int D.27679;
  unsigned int D.27680;
  unsigned int D.27681;
  struct MonoClass * parent;

  D.27673 = field->field;
  parent = D.27673->parent;
  D.27674 = BIT_FIELD_REF <*parent, 32, 160>;
  D.27675 = D.27674 & 4;
  if (D.27675 == 0) goto <D.27676>; else goto <D.27677>;
  <D.27676>:
  mono_class_init (parent);
  <D.27677>:
  D.27673 = field->field;
  D.27679 = D.27673->offset;
  D.27680 = (unsigned int) D.27679;
  D.27681 = D.27680 + 4294967288;
  D.27678 = (gint32) D.27681;
  return D.27678;
}


ves_icall_get_event_info (struct MonoReflectionMonoEvent * event, struct MonoEventInfo * info)
{
  struct MonoVTable * D.27683;
  struct MonoReflectionType * * D.27684;
  struct MonoClass * D.27685;
  struct MonoType * D.27686;
  struct MonoReflectionType * D.27687;
  struct MonoReflectionType * * D.27688;
  struct MonoEvent * D.27689;
  struct MonoClass * D.27690;
  struct MonoType * D.27691;
  struct MonoReflectionType * D.27692;
  struct MonoString * * D.27693;
  const char * D.27694;
  struct MonoString * D.27695;
  unsigned int D.27696;
  struct MonoReflectionMethod * * D.27697;
  struct MonoObject * iftmp.105;
  struct MonoMethod * D.27699;
  struct MonoReflectionMethod * * D.27703;
  struct MonoObject * iftmp.106;
  struct MonoMethod * D.27705;
  struct MonoReflectionMethod * * D.27709;
  struct MonoObject * iftmp.107;
  struct MonoMethod * D.27711;
  struct MonoMethod * * D.27715;
  unsigned int n.108;
  unsigned int D.27719;
  struct MonoMethod * * D.27720;
  struct MonoMethod * D.27721;
  struct MonoArray * * D.27722;
  struct MonoClass * D.27723;
  unsigned int n.109;
  struct MonoArray * D.27725;
  struct MonoArray * D.27726;
  unsigned int i.110;
  unsigned int i.111;
  unsigned int D.27729;
  struct MonoMethod * * D.27730;
  struct MonoMethod * D.27731;
  struct MonoReflectionMethod * D.27732;
  struct MonoDomain * domain;

  D.27683 = MEM[(struct MonoObject *)event].vtable;
  domain = D.27683->domain;
  D.27684 = &info->reflected_type;
  D.27685 = event->klass;
  D.27686 = &D.27685->byval_arg;
  D.27687 = mono_type_get_object (domain, D.27686);
  mono_gc_wbarrier_generic_store (D.27684, D.27687);
  D.27688 = &info->declaring_type;
  D.27689 = event->event;
  D.27690 = D.27689->parent;
  D.27691 = &D.27690->byval_arg;
  D.27692 = mono_type_get_object (domain, D.27691);
  mono_gc_wbarrier_generic_store (D.27688, D.27692);
  D.27693 = &info->name;
  D.27689 = event->event;
  D.27694 = D.27689->name;
  D.27695 = mono_string_new (domain, D.27694);
  mono_gc_wbarrier_generic_store (D.27693, D.27695);
  D.27689 = event->event;
  D.27696 = D.27689->attrs;
  info->attrs = D.27696;
  D.27697 = &info->add_method;
  D.27689 = event->event;
  D.27699 = D.27689->add;
  if (D.27699 != 0B) goto <D.27700>; else goto <D.27701>;
  <D.27700>:
  D.27689 = event->event;
  D.27699 = D.27689->add;
  iftmp.105 = mono_method_get_object (domain, D.27699, 0B);
  goto <D.27702>;
  <D.27701>:
  iftmp.105 = 0B;
  <D.27702>:
  mono_gc_wbarrier_generic_store (D.27697, iftmp.105);
  D.27703 = &info->remove_method;
  D.27689 = event->event;
  D.27705 = D.27689->remove;
  if (D.27705 != 0B) goto <D.27706>; else goto <D.27707>;
  <D.27706>:
  D.27689 = event->event;
  D.27705 = D.27689->remove;
  iftmp.106 = mono_method_get_object (domain, D.27705, 0B);
  goto <D.27708>;
  <D.27707>:
  iftmp.106 = 0B;
  <D.27708>:
  mono_gc_wbarrier_generic_store (D.27703, iftmp.106);
  D.27709 = &info->raise_method;
  D.27689 = event->event;
  D.27711 = D.27689->raise;
  if (D.27711 != 0B) goto <D.27712>; else goto <D.27713>;
  <D.27712>:
  D.27689 = event->event;
  D.27711 = D.27689->raise;
  iftmp.107 = mono_method_get_object (domain, D.27711, 0B);
  goto <D.27714>;
  <D.27713>:
  iftmp.107 = 0B;
  <D.27714>:
  mono_gc_wbarrier_generic_store (D.27709, iftmp.107);
  D.27689 = event->event;
  D.27715 = D.27689->other;
  if (D.27715 != 0B) goto <D.27716>; else goto <D.27717>;
  <D.27716>:
  {
    int i;
    int n;

    n = 0;
    goto <D.21164>;
    <D.21163>:
    n = n + 1;
    <D.21164>:
    D.27689 = event->event;
    D.27715 = D.27689->other;
    n.108 = (unsigned int) n;
    D.27719 = n.108 * 4;
    D.27720 = D.27715 + D.27719;
    D.27721 = *D.27720;
    if (D.27721 != 0B) goto <D.21163>; else goto <D.21165>;
    <D.21165>:
    D.27722 = &info->other_methods;
    D.27723 = mono_defaults.method_info_class;
    n.109 = (unsigned int) n;
    D.27725 = mono_array_new (domain, D.27723, n.109);
    mono_gc_wbarrier_generic_store (D.27722, D.27725);
    i = 0;
    goto <D.21168>;
    <D.21167>:
    {
      void * * __p;

      D.27726 = info->other_methods;
      i.110 = (unsigned int) i;
      __p = mono_array_addr_with_size (D.27726, 4, i.110);
      D.27726 = info->other_methods;
      D.27689 = event->event;
      D.27715 = D.27689->other;
      i.111 = (unsigned int) i;
      D.27729 = i.111 * 4;
      D.27730 = D.27715 + D.27729;
      D.27731 = *D.27730;
      D.27732 = mono_method_get_object (domain, D.27731, 0B);
      mono_gc_wbarrier_set_arrayref (D.27726, __p, D.27732);
    }
    i = i + 1;
    <D.21168>:
    if (i < n) goto <D.21167>; else goto <D.21169>;
    <D.21169>:
  }
  <D.27717>:
}


ves_icall_InternalInvoke (struct MonoReflectionMethod * method, struct MonoObject * this, struct MonoArray * params, struct MonoException * * exc)
{
  <unnamed type> D.27733;
  short unsigned int D.27736;
  int D.27737;
  int D.27738;
  struct MonoVTable * D.27741;
  struct MonoDomain * D.27742;
  struct MonoClass * D.27743;
  struct MonoVTable * D.27744;
  struct MonoException * D.27747;
  struct MonoObject * D.27748;
  struct MonoObject * D.27751;
  struct MonoClass * D.27754;
  struct MonoImage * D.27755;
  struct MonoException * D.27756;
  unsigned int D.27757;
  unsigned int D.27758;
  int D.21468;
  int iftmp.112;
  int D.21467;
  const char[6] * D.27765;
  unsigned char D.27766;
  int D.27767;
  unsigned char D.27768;
  int D.27769;
  const unsigned char * D.27774;
  unsigned char D.27775;
  int D.27776;
  const unsigned char * D.27777;
  unsigned char D.27778;
  int D.27779;
  const unsigned char * D.27784;
  unsigned char D.27785;
  int D.27786;
  const unsigned char * D.27787;
  unsigned char D.27788;
  int D.27789;
  const unsigned char * D.27794;
  unsigned char D.27795;
  int D.27796;
  const unsigned char * D.27797;
  unsigned char D.27798;
  int D.27799;
  const char * D.27801;
  unsigned int D.27804;
  unsigned int D.27805;
  struct MonoException * D.27808;
  struct MonoType * D.27809;
  unsigned int D.27810;
  unsigned int D.27811;
  struct MonoException * D.27814;
  int iftmp.113;
  unsigned int D.27818;
  short unsigned int D.27820;
  int D.27821;
  struct MonoException * D.27824;
  unsigned int D.27825;
  unsigned int D.27826;
  int D.21477;
  int iftmp.114;
  int D.21476;
  unsigned char D.27832;
  int D.27833;
  const unsigned char * D.27838;
  unsigned char D.27839;
  int D.27840;
  const unsigned char * D.27845;
  unsigned char D.27846;
  int D.27847;
  const unsigned char * D.27852;
  unsigned char D.27853;
  int D.27854;
  struct MonoException * D.27860;
  struct MonoAssembly * D.27861;
  int D.27862;
  struct MonoException * D.27865;
  unsigned int D.27866;
  unsigned int D.27867;
  int D.27870;
  struct MonoException * D.27873;
  unsigned char D.27874;
  int D.21486;
  int iftmp.115;
  int D.21485;
  unsigned char D.27880;
  int D.27881;
  const unsigned char * D.27886;
  unsigned char D.27887;
  int D.27888;
  const unsigned char * D.27893;
  unsigned char D.27894;
  int D.27895;
  const unsigned char * D.27900;
  unsigned char D.27901;
  int D.27902;
  unsigned int D.27906;
  unsigned int pcount.116;
  unsigned int D.27908;
  unsigned int i.117;
  unsigned int D.27910;
  uintptr_t * D.27911;
  unsigned int i.118;
  char * D.27913;
  void * D.27914;
  int32_t * D.27915;
  int D.27916;
  unsigned int D.27917;
  int D.27918;
  int D.27922;
  _Bool D.27923;
  long int D.27924;
  long int D.27925;
  unsigned int D.27928;
  unsigned int D.27929;
  struct MonoVTable * D.27930;
  struct MonoDomain * D.27931;
  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.27733 = mono_security_get_mode ();
  if (D.27733 == 1) goto <D.27734>; else goto <D.27735>;
  <D.27734>:
  mono_security_core_clr_ensure_reflection_access_method (m);
  <D.27735>:
  D.27736 = m->flags;
  D.27737 = (int) D.27736;
  D.27738 = D.27737 & 16;
  if (D.27738 == 0) goto <D.27739>; else goto <D.27740>;
  <D.27739>:
  D.27741 = MEM[(struct MonoObject *)method].vtable;
  D.27742 = D.27741->domain;
  D.27743 = m->klass;
  D.27744 = mono_class_vtable_full (D.27742, D.27743, 0);
  if (D.27744 == 0B) goto <D.27745>; else goto <D.27746>;
  <D.27745>:
  D.27743 = m->klass;
  D.27747 = mono_class_get_exception_for_failure (D.27743);
  mono_gc_wbarrier_generic_store (exc, D.27747);
  D.27748 = 0B;
  return D.27748;
  <D.27746>:
  if (this != 0B) goto <D.27749>; else goto <D.27750>;
  <D.27749>:
  D.27743 = m->klass;
  D.27751 = mono_object_isinst (this, D.27743);
  if (D.27751 == 0B) goto <D.27752>; else goto <D.27753>;
  <D.27752>:
  {
    char * this_name;
    char * target_name;
    char * msg;

    D.27754 = mono_object_get_class (this);
    this_name = mono_type_get_full_name (D.27754);
    D.27743 = m->klass;
    target_name = mono_type_get_full_name (D.27743);
    msg = monoeg_g_strdup_printf ("Object of type \'%s\' doesn\'t match target type \'%s\'", this_name, target_name);
    D.27755 = mono_defaults.corlib;
    D.27756 = mono_exception_from_name_msg (D.27755, "System.Reflection", "TargetException", msg);
    mono_gc_wbarrier_generic_store (exc, D.27756);
    monoeg_g_free (msg);
    monoeg_g_free (target_name);
    monoeg_g_free (this_name);
    D.27748 = 0B;
    return D.27748;
  }
  <D.27753>:
  m = mono_object_get_virtual_method (this, m);
  D.27743 = m->klass;
  D.27757 = BIT_FIELD_REF <*D.27743, 32, 160>;
  D.27758 = D.27757 & 8;
  if (D.27758 != 0) goto <D.27759>; else goto <D.27760>;
  <D.27759>:
  obj = mono_object_unbox (this);
  <D.27760>:
  goto <D.27761>;
  <D.27750>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = m->name;
      D.27765 = ".ctor";
      D.27766 = MEM[(const unsigned char *)D.27765];
      D.27767 = (int) D.27766;
      D.27768 = *__s2;
      D.27769 = (int) D.27768;
      __result = D.27767 - D.27769;
      {
        if (__s2_len != 0) goto <D.27770>; else goto <D.27771>;
        <D.27770>:
        if (__result == 0) goto <D.27772>; else goto <D.27773>;
        <D.27772>:
        D.27774 = &MEM[(void *)".ctor" + 1B];
        D.27775 = *D.27774;
        D.27776 = (int) D.27775;
        D.27777 = __s2 + 1;
        D.27778 = *D.27777;
        D.27779 = (int) D.27778;
        __result = D.27776 - D.27779;
        if (__s2_len > 1) goto <D.27780>; else goto <D.27781>;
        <D.27780>:
        if (__result == 0) goto <D.27782>; else goto <D.27783>;
        <D.27782>:
        D.27784 = &MEM[(void *)".ctor" + 2B];
        D.27785 = *D.27784;
        D.27786 = (int) D.27785;
        D.27787 = __s2 + 2;
        D.27788 = *D.27787;
        D.27789 = (int) D.27788;
        __result = D.27786 - D.27789;
        if (__s2_len > 2) goto <D.27790>; else goto <D.27791>;
        <D.27790>:
        if (__result == 0) goto <D.27792>; else goto <D.27793>;
        <D.27792>:
        D.27794 = &MEM[(void *)".ctor" + 3B];
        D.27795 = *D.27794;
        D.27796 = (int) D.27795;
        D.27797 = __s2 + 3;
        D.27798 = *D.27797;
        D.27799 = (int) D.27798;
        __result = D.27796 - D.27799;
        <D.27793>:
        <D.27791>:
        <D.27783>:
        <D.27781>:
        <D.27773>:
        <D.27771>:
      }
      D.21467 = __result;
    }
    iftmp.112 = -D.21467;
    goto <D.27800>;
    <D.27764>:
    D.27801 = m->name;
    iftmp.112 = __builtin_strcmp (D.27801, ".ctor");
    <D.27800>:
    D.21468 = iftmp.112;
  }
  if (D.21468 != 0) goto <D.27802>; else goto <D.27803>;
  <D.27802>:
  D.27804 = BIT_FIELD_REF <*m, 32, 160>;
  D.27805 = D.27804 & 124;
  if (D.27805 == 0) goto <D.27806>; else goto <D.27807>;
  <D.27806>:
  D.27755 = mono_defaults.corlib;
  D.27808 = mono_exception_from_name_msg (D.27755, "System.Reflection", "TargetException", "Non-static method requires a target.");
  mono_gc_wbarrier_generic_store (exc, D.27808);
  D.27748 = 0B;
  return D.27748;
  <D.27807>:
  <D.27803>:
  <D.27761>:
  <D.27740>:
  D.27809 = sig->ret;
  D.27810 = BIT_FIELD_REF <*D.27809, 32, 32>;
  D.27811 = D.27810 & 1073741824;
  if (D.27811 != 0) goto <D.27812>; else goto <D.27813>;
  <D.27812>:
  D.27755 = mono_defaults.corlib;
  D.27814 = mono_exception_from_name_msg (D.27755, "System", "NotSupportedException", "Cannot invoke method returning ByRef type via reflection");
  mono_gc_wbarrier_generic_store (exc, D.27814);
  D.27748 = 0B;
  return D.27748;
  <D.27813>:
  if (params != 0B) goto <D.27816>; else goto <D.27817>;
  <D.27816>:
  D.27818 = mono_array_length (params);
  iftmp.113 = (int) D.27818;
  goto <D.27819>;
  <D.27817>:
  iftmp.113 = 0;
  <D.27819>:
  pcount = iftmp.113;
  D.27820 = sig->param_count;
  D.27821 = (int) D.27820;
  if (D.27821 != pcount) goto <D.27822>; else goto <D.27823>;
  <D.27822>:
  D.27755 = mono_defaults.corlib;
  D.27824 = mono_exception_from_name (D.27755, "System.Reflection", "TargetParameterCountException");
  mono_gc_wbarrier_generic_store (exc, D.27824);
  D.27748 = 0B;
  return D.27748;
  <D.27823>:
  D.27743 = m->klass;
  D.27825 = D.27743->flags;
  D.27826 = D.27825 & 128;
  if (D.27826 != 0) goto <D.27827>; else goto <D.27828>;
  <D.27827>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = m->name;
      D.27765 = ".ctor";
      D.27766 = MEM[(const unsigned char *)D.27765];
      D.27767 = (int) D.27766;
      D.27832 = *__s2;
      D.27833 = (int) D.27832;
      __result = D.27767 - D.27833;
      {
        if (__s2_len != 0) goto <D.27834>; else goto <D.27835>;
        <D.27834>:
        if (__result == 0) goto <D.27836>; else goto <D.27837>;
        <D.27836>:
        D.27774 = &MEM[(void *)".ctor" + 1B];
        D.27775 = *D.27774;
        D.27776 = (int) D.27775;
        D.27838 = __s2 + 1;
        D.27839 = *D.27838;
        D.27840 = (int) D.27839;
        __result = D.27776 - D.27840;
        if (__s2_len > 1) goto <D.27841>; else goto <D.27842>;
        <D.27841>:
        if (__result == 0) goto <D.27843>; else goto <D.27844>;
        <D.27843>:
        D.27784 = &MEM[(void *)".ctor" + 2B];
        D.27785 = *D.27784;
        D.27786 = (int) D.27785;
        D.27845 = __s2 + 2;
        D.27846 = *D.27845;
        D.27847 = (int) D.27846;
        __result = D.27786 - D.27847;
        if (__s2_len > 2) goto <D.27848>; else goto <D.27849>;
        <D.27848>:
        if (__result == 0) goto <D.27850>; else goto <D.27851>;
        <D.27850>:
        D.27794 = &MEM[(void *)".ctor" + 3B];
        D.27795 = *D.27794;
        D.27796 = (int) D.27795;
        D.27852 = __s2 + 3;
        D.27853 = *D.27852;
        D.27854 = (int) D.27853;
        __result = D.27796 - D.27854;
        <D.27851>:
        <D.27849>:
        <D.27844>:
        <D.27842>:
        <D.27837>:
        <D.27835>:
      }
      D.21476 = __result;
    }
    iftmp.114 = -D.21476;
    goto <D.27855>;
    <D.27831>:
    D.27801 = m->name;
    iftmp.114 = __builtin_strcmp (D.27801, ".ctor");
    <D.27855>:
    D.21477 = iftmp.114;
  }
  if (D.21477 == 0) goto <D.27856>; else goto <D.27857>;
  <D.27856>:
  if (this == 0B) goto <D.27858>; else goto <D.27859>;
  <D.27858>:
  D.27755 = mono_defaults.corlib;
  D.27860 = mono_exception_from_name_msg (D.27755, "System.Reflection", "TargetException", "Cannot invoke constructor of an abstract class.");
  mono_gc_wbarrier_generic_store (exc, D.27860);
  D.27748 = 0B;
  return D.27748;
  <D.27859>:
  <D.27857>:
  <D.27828>:
  D.27743 = m->klass;
  image = D.27743->image;
  D.27861 = image->assembly;
  D.27862 = D.27861->ref_only;
  if (D.27862 != 0) goto <D.27863>; else goto <D.27864>;
  <D.27863>:
  D.27865 = 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.27865);
  D.27748 = 0B;
  return D.27748;
  <D.27864>:
  D.27866 = BIT_FIELD_REF <*image, 32, 128>;
  D.27867 = D.27866 & 8;
  if (D.27867 != 0) goto <D.27868>; else goto <D.27869>;
  <D.27868>:
  D.27870 = MEM[(struct MonoDynamicImage *)image].run;
  if (D.27870 == 0) goto <D.27871>; else goto <D.27872>;
  <D.27871>:
  D.27873 = mono_get_exception_not_supported ("Cannot invoke a method in a dynamic assembly without run access.");
  mono_gc_wbarrier_generic_store (exc, D.27873);
  D.27748 = 0B;
  return D.27748;
  <D.27872>:
  <D.27869>:
  D.27743 = m->klass;
  D.27874 = D.27743->rank;
  if (D.27874 != 0) goto <D.27875>; else goto <D.27876>;
  <D.27875>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = m->name;
      D.27765 = ".ctor";
      D.27766 = MEM[(const unsigned char *)D.27765];
      D.27767 = (int) D.27766;
      D.27880 = *__s2;
      D.27881 = (int) D.27880;
      __result = D.27767 - D.27881;
      {
        if (__s2_len != 0) goto <D.27882>; else goto <D.27883>;
        <D.27882>:
        if (__result == 0) goto <D.27884>; else goto <D.27885>;
        <D.27884>:
        D.27774 = &MEM[(void *)".ctor" + 1B];
        D.27775 = *D.27774;
        D.27776 = (int) D.27775;
        D.27886 = __s2 + 1;
        D.27887 = *D.27886;
        D.27888 = (int) D.27887;
        __result = D.27776 - D.27888;
        if (__s2_len > 1) goto <D.27889>; else goto <D.27890>;
        <D.27889>:
        if (__result == 0) goto <D.27891>; else goto <D.27892>;
        <D.27891>:
        D.27784 = &MEM[(void *)".ctor" + 2B];
        D.27785 = *D.27784;
        D.27786 = (int) D.27785;
        D.27893 = __s2 + 2;
        D.27894 = *D.27893;
        D.27895 = (int) D.27894;
        __result = D.27786 - D.27895;
        if (__s2_len > 2) goto <D.27896>; else goto <D.27897>;
        <D.27896>:
        if (__result == 0) goto <D.27898>; else goto <D.27899>;
        <D.27898>:
        D.27794 = &MEM[(void *)".ctor" + 3B];
        D.27795 = *D.27794;
        D.27796 = (int) D.27795;
        D.27900 = __s2 + 3;
        D.27901 = *D.27900;
        D.27902 = (int) D.27901;
        __result = D.27796 - D.27902;
        <D.27899>:
        <D.27897>:
        <D.27892>:
        <D.27890>:
        <D.27885>:
        <D.27883>:
      }
      D.21485 = __result;
    }
    iftmp.115 = -D.21485;
    goto <D.27903>;
    <D.27879>:
    D.27801 = m->name;
    iftmp.115 = __builtin_strcmp (D.27801, ".ctor");
    <D.27903>:
    D.21486 = iftmp.115;
  }
  if (D.21486 == 0) goto <D.27904>; else goto <D.27905>;
  <D.27904>:
  {
    int i;
    uintptr_t * lengths;
    intptr_t * lower_bounds;

    D.27906 = mono_array_length (params);
    pcount = (int) D.27906;
    pcount.116 = (unsigned int) pcount;
    D.27908 = pcount.116 * 4;
    lengths = __builtin_alloca (D.27908);
    i = 0;
    goto <D.21491>;
    <D.21490>:
    i.117 = (unsigned int) i;
    D.27910 = i.117 * 4;
    D.27911 = lengths + D.27910;
    i.118 = (unsigned int) i;
    D.27913 = mono_array_addr_with_size (params, 4, i.118);
    D.27914 = MEM[(void * *)D.27913];
    D.27915 = D.27914 + 8;
    D.27916 = *D.27915;
    D.27917 = (unsigned int) D.27916;
    *D.27911 = D.27917;
    i = i + 1;
    <D.21491>:
    if (i < pcount) goto <D.21490>; else goto <D.21492>;
    <D.21492>:
    D.27743 = m->klass;
    D.27874 = D.27743->rank;
    D.27918 = (int) D.27874;
    if (D.27918 == pcount) goto <D.27919>; else goto <D.27920>;
    <D.27919>:
    lower_bounds = 0B;
    goto <D.27921>;
    <D.27920>:
    D.27743 = m->klass;
    D.27874 = D.27743->rank;
    D.27918 = (int) D.27874;
    D.27922 = D.27918 * 2;
    D.27923 = D.27922 != pcount;
    D.27924 = (long int) D.27923;
    D.27925 = __builtin_expect (D.27924, 0);
    if (D.27925 != 0) goto <D.27926>; else goto <D.27927>;
    <D.27926>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "icall.c", 2835, "pcount == (m->klass->rank * 2)");
    <D.27927>:
    lower_bounds = lengths;
    D.27743 = m->klass;
    D.27874 = D.27743->rank;
    D.27928 = (unsigned int) D.27874;
    D.27929 = D.27928 * 4;
    lengths = lengths + D.27929;
    <D.27921>:
    D.27930 = MEM[(struct MonoObject *)params].vtable;
    D.27931 = D.27930->domain;
    D.27743 = m->klass;
    D.27748 = mono_array_new_full (D.27931, D.27743, lengths, lower_bounds);
    return D.27748;
  }
  <D.27905>:
  <D.27876>:
  D.27748 = mono_runtime_invoke_array (m, obj, params, 0B);
  return D.27748;
}


ves_icall_MonoMethod_GetGenericMethodDefinition (struct MonoReflectionMethod * method)
{
  struct MonoMethod * D.27933;
  unsigned int D.27934;
  unsigned int D.27935;
  struct MonoReflectionMethod * D.27938;
  unsigned int D.27939;
  unsigned int D.27942;
  unsigned int D.27943;
  struct MonoClass * D.27946;
  struct MonoImage * D.27947;
  unsigned int D.27948;
  unsigned int D.27949;
  struct MonoGHashTable * D.27952;
  struct MonoGenericInst * D.27955;
  struct MonoGenericContext * D.27958;
  struct MonoGenericContext * D.27961;
  struct MonoVTable * D.27962;
  struct MonoDomain * D.27963;
  struct MonoMethodInflated * imethod;
  struct MonoMethod * result;

  D.27933 = method->method;
  D.27934 = BIT_FIELD_REF <*D.27933, 32, 160>;
  D.27935 = D.27934 & 2048;
  if (D.27935 != 0) goto <D.27936>; else goto <D.27937>;
  <D.27936>:
  D.27938 = method;
  return D.27938;
  <D.27937>:
  D.27933 = method->method;
  D.27934 = BIT_FIELD_REF <*D.27933, 32, 160>;
  D.27939 = D.27934 & 4096;
  if (D.27939 == 0) goto <D.27940>; else goto <D.27941>;
  <D.27940>:
  D.27938 = 0B;
  return D.27938;
  <D.27941>:
  imethod = method->method;
  result = imethod->declaring;
  D.27942 = BIT_FIELD_REF <*result, 32, 160>;
  D.27943 = D.27942 & 2048;
  if (D.27943 == 0) goto <D.27944>; else goto <D.27945>;
  <D.27944>:
  D.27938 = 0B;
  return D.27938;
  <D.27945>:
  D.27933 = method->method;
  D.27946 = D.27933->klass;
  D.27947 = D.27946->image;
  D.27948 = BIT_FIELD_REF <*D.27947, 32, 128>;
  D.27949 = D.27948 & 8;
  if (D.27949 != 0) goto <D.27950>; else goto <D.27951>;
  <D.27950>:
  {
    struct MonoDynamicImage * image;
    struct MonoReflectionMethod * res;

    D.27933 = method->method;
    D.27946 = D.27933->klass;
    image = D.27946->image;
    mono_image_lock (image);
    D.27952 = image->generic_def_objects;
    res = mono_g_hash_table_lookup (D.27952, imethod);
    mono_image_unlock (image);
    if (res != 0B) goto <D.27953>; else goto <D.27954>;
    <D.27953>:
    D.27938 = res;
    return D.27938;
    <D.27954>:
  }
  <D.27951>:
  D.27955 = imethod->context.class_inst;
  if (D.27955 != 0B) goto <D.27956>; else goto <D.27957>;
  <D.27956>:
  {
    struct MonoClass * klass;

    klass = MEM[(struct MonoMethod *)imethod].klass;
    D.27958 = mono_class_get_context (klass);
    if (D.27958 != 0B) goto <D.27959>; else goto <D.27960>;
    <D.27959>:
    D.27961 = mono_class_get_context (klass);
    result = mono_class_inflate_generic_method_full (result, klass, D.27961);
    <D.27960>:
  }
  <D.27957>:
  D.27962 = MEM[(struct MonoObject *)method].vtable;
  D.27963 = D.27962->domain;
  D.27938 = mono_method_get_object (D.27963, result, 0B);
  return D.27938;
}


ves_icall_System_Reflection_Module_ResolveTypeToken (struct MonoImage * image, guint32 token, struct MonoArray * type_args, struct MonoArray * method_args, MonoResolveTokenError * error)
{
  unsigned int D.27965;
  int token.119;
  unsigned int table.120;
  unsigned int D.27968;
  struct MonoType * D.27973;
  unsigned int D.27974;
  unsigned int D.27975;
  struct MonoType * iftmp.121;
  struct MonoType * iftmp.122;
  <unnamed-unsigned:24> D.27991;
  int D.27992;
  struct MonoLoaderError * D.27993;
  struct MonoLoaderError * D.27996;
  struct MonoException * D.27997;
  struct MonoClass * klass;
  int table;
  int index;
  struct MonoGenericContext context;

  try
    {
      D.27965 = token >> 24;
      table = (int) D.27965;
      token.119 = (int) token;
      index = token.119 & 16777215;
      *error = 2;
      table.120 = (unsigned int) table;
      D.27968 = table.120 + 4294967295;
      if (D.27968 > 1) goto <D.27969>; else goto <D.27970>;
      <D.27969>:
      if (table != 27) goto <D.27971>; else goto <D.27972>;
      <D.27971>:
      *error = 1;
      D.27973 = 0B;
      return D.27973;
      <D.27972>:
      <D.27970>:
      D.27974 = BIT_FIELD_REF <*image, 32, 128>;
      D.27975 = D.27974 & 8;
      if (D.27975 != 0) goto <D.27976>; else goto <D.27977>;
      <D.27976>:
      table.120 = (unsigned int) table;
      D.27968 = table.120 + 4294967295;
      if (D.27968 <= 1) goto <D.27978>; else goto <D.27979>;
      <D.27978>:
      klass = mono_lookup_dynamic_token_class (image, token, 0, 0B, 0B);
      if (klass != 0B) goto <D.27981>; else goto <D.27982>;
      <D.27981>:
      iftmp.121 = &klass->byval_arg;
      goto <D.27983>;
      <D.27982>:
      iftmp.121 = 0B;
      <D.27983>:
      D.27973 = iftmp.121;
      return D.27973;
      <D.27979>:
      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.27985>; else goto <D.27986>;
      <D.27985>:
      iftmp.122 = &klass->byval_arg;
      goto <D.27987>;
      <D.27986>:
      iftmp.122 = 0B;
      <D.27987>:
      D.27973 = iftmp.122;
      return D.27973;
      <D.27977>:
      if (index <= 0) goto <D.27988>; else goto <D.27990>;
      <D.27990>:
      D.27991 = image->tables[table].rows;
      D.27992 = (int) D.27991;
      if (D.27992 < index) goto <D.27988>; else goto <D.27989>;
      <D.27988>:
      *error = 0;
      D.27973 = 0B;
      return D.27973;
      <D.27989>:
      init_generic_context_from_args (&context, type_args, method_args);
      klass = mono_class_get_full (image, token, &context);
      D.27993 = mono_loader_get_last_error ();
      if (D.27993 != 0B) goto <D.27994>; else goto <D.27995>;
      <D.27994>:
      D.27996 = mono_loader_get_last_error ();
      D.27997 = mono_loader_error_prepare_exception (D.27996);
      mono_raise_exception (D.27997);
      <D.27995>:
      if (klass != 0B) goto <D.27998>; else goto <D.27999>;
      <D.27998>:
      D.27973 = &klass->byval_arg;
      return D.27973;
      <D.27999>:
      D.27973 = 0B;
      return D.27973;
    }
  finally
    {
      context = {CLOBBER};
    }
}


init_generic_context_from_args (struct MonoGenericContext * context, struct MonoArray * type_args, struct MonoArray * method_args)
{
  unsigned int D.28004;
  int D.28005;
  char * D.28006;
  struct MonoGenericInst * D.28007;
  unsigned int D.28011;
  int D.28012;
  char * D.28013;
  struct MonoGenericInst * D.28014;

  if (type_args != 0B) goto <D.28002>; else goto <D.28003>;
  <D.28002>:
  D.28004 = mono_array_length (type_args);
  D.28005 = (int) D.28004;
  D.28006 = mono_array_addr_with_size (type_args, 4, 0);
  D.28007 = mono_metadata_get_generic_inst (D.28005, D.28006);
  context->class_inst = D.28007;
  goto <D.28008>;
  <D.28003>:
  context->class_inst = 0B;
  <D.28008>:
  if (method_args != 0B) goto <D.28009>; else goto <D.28010>;
  <D.28009>:
  D.28011 = mono_array_length (method_args);
  D.28012 = (int) D.28011;
  D.28013 = mono_array_addr_with_size (method_args, 4, 0);
  D.28014 = mono_metadata_get_generic_inst (D.28012, D.28013);
  context->method_inst = D.28014;
  goto <D.28015>;
  <D.28010>:
  context->method_inst = 0B;
  <D.28015>:
}


ves_icall_System_Reflection_Module_ResolveStringToken (struct MonoImage * image, guint32 token, MonoResolveTokenError * error)
{
  int token.123;
  unsigned int D.28017;
  struct MonoString * D.28020;
  unsigned int D.28021;
  unsigned int D.28022;
  unsigned int index.124;
  unsigned int D.28029;
  struct MonoDomain * D.28030;
  unsigned int index.125;
  int index;

  token.123 = (int) token;
  index = token.123 & 16777215;
  *error = 2;
  D.28017 = token & 4278190080;
  if (D.28017 != 1879048192) goto <D.28018>; else goto <D.28019>;
  <D.28018>:
  *error = 1;
  D.28020 = 0B;
  return D.28020;
  <D.28019>:
  D.28021 = BIT_FIELD_REF <*image, 32, 128>;
  D.28022 = D.28021 & 8;
  if (D.28022 != 0) goto <D.28023>; else goto <D.28024>;
  <D.28023>:
  D.28020 = mono_lookup_dynamic_token_class (image, token, 0, 0B, 0B);
  return D.28020;
  <D.28024>:
  if (index <= 0) goto <D.28025>; else goto <D.28027>;
  <D.28027>:
  index.124 = (unsigned int) index;
  D.28029 = image->heap_us.size;
  if (index.124 >= D.28029) goto <D.28025>; else goto <D.28026>;
  <D.28025>:
  *error = 0;
  D.28020 = 0B;
  return D.28020;
  <D.28026>:
  D.28030 = mono_domain_get ();
  index.125 = (unsigned int) index;
  D.28020 = mono_ldstr (D.28030, image, index.125);
  return D.28020;
}


ves_icall_System_Reflection_Module_ResolveSignature (struct MonoImage * image, guint32 token, MonoResolveTokenError * error)
{
  unsigned int D.28033;
  int token.126;
  struct MonoArray * D.28037;
  unsigned int D.28038;
  unsigned int D.28039;
  struct MonoTableInfo * D.28045;
  <unnamed-unsigned:24> D.28046;
  int D.28047;
  const struct MonoTableInfo * D.28048;
  int D.28049;
  const char * ptr.127;
  const char * ptr.128;
  struct MonoDomain * D.28052;
  struct MonoClass * D.28053;
  char * D.28054;
  int table;
  int idx;
  struct MonoTableInfo * tables;
  guint32 sig;
  guint32 len;
  const char * ptr;
  struct MonoArray * res;

  try
    {
      D.28033 = token >> 24;
      table = (int) D.28033;
      token.126 = (int) token;
      idx = token.126 & 16777215;
      tables = &image->tables;
      *error = 0;
      if (table != 17) goto <D.28035>; else goto <D.28036>;
      <D.28035>:
      D.28037 = 0B;
      return D.28037;
      <D.28036>:
      D.28038 = BIT_FIELD_REF <*image, 32, 128>;
      D.28039 = D.28038 & 8;
      if (D.28039 != 0) goto <D.28040>; else goto <D.28041>;
      <D.28040>:
      D.28037 = 0B;
      return D.28037;
      <D.28041>:
      if (idx == 0) goto <D.28042>; else goto <D.28044>;
      <D.28044>:
      D.28045 = tables + 204;
      D.28046 = D.28045->rows;
      D.28047 = (int) D.28046;
      if (D.28047 < idx) goto <D.28042>; else goto <D.28043>;
      <D.28042>:
      D.28037 = 0B;
      return D.28037;
      <D.28043>:
      D.28048 = tables + 204;
      D.28049 = idx + -1;
      sig = mono_metadata_decode_row_col (D.28048, D.28049, 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.28052 = mono_domain_get ();
      D.28053 = mono_defaults.byte_class;
      res = mono_array_new (D.28052, D.28053, len);
      D.28054 = mono_array_addr_with_size (res, 1, 0);
      ptr.128 = ptr;
      memcpy (D.28054, ptr.128, len);
      D.28037 = res;
      return D.28037;
    }
  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.28057;
  int token.129;
  struct MonoMethod * D.28065;
  unsigned int D.28066;
  unsigned int D.28067;
  int D.28074;
  <unnamed-unsigned:24> D.28080;
  int D.28081;
  int D.28084;
  struct MonoLoaderError * D.28087;
  struct MonoLoaderError * D.28090;
  struct MonoException * D.28091;
  int table;
  int index;
  struct MonoGenericContext context;
  struct MonoMethod * method;

  try
    {
      D.28057 = token >> 24;
      table = (int) D.28057;
      token.129 = (int) token;
      index = token.129 & 16777215;
      *error = 2;
      if (table != 6) goto <D.28059>; else goto <D.28060>;
      <D.28059>:
      if (table != 43) goto <D.28061>; else goto <D.28062>;
      <D.28061>:
      if (table != 10) goto <D.28063>; else goto <D.28064>;
      <D.28063>:
      *error = 1;
      D.28065 = 0B;
      return D.28065;
      <D.28064>:
      <D.28062>:
      <D.28060>:
      D.28066 = BIT_FIELD_REF <*image, 32, 128>;
      D.28067 = D.28066 & 8;
      if (D.28067 != 0) goto <D.28068>; else goto <D.28069>;
      <D.28068>:
      if (table == 6) goto <D.28070>; else goto <D.28071>;
      <D.28070>:
      D.28065 = mono_lookup_dynamic_token_class (image, token, 0, 0B, 0B);
      return D.28065;
      <D.28071>:
      if (table == 10) goto <D.28072>; else goto <D.28073>;
      <D.28072>:
      D.28074 = mono_memberref_is_method (image, token);
      if (D.28074 == 0) goto <D.28075>; else goto <D.28076>;
      <D.28075>:
      *error = 1;
      D.28065 = 0B;
      return D.28065;
      <D.28076>:
      <D.28073>:
      init_generic_context_from_args (&context, type_args, method_args);
      D.28065 = mono_lookup_dynamic_token_class (image, token, 0, 0B, &context);
      return D.28065;
      <D.28069>:
      if (index <= 0) goto <D.28077>; else goto <D.28079>;
      <D.28079>:
      D.28080 = image->tables[table].rows;
      D.28081 = (int) D.28080;
      if (D.28081 < index) goto <D.28077>; else goto <D.28078>;
      <D.28077>:
      *error = 0;
      D.28065 = 0B;
      return D.28065;
      <D.28078>:
      if (table == 10) goto <D.28082>; else goto <D.28083>;
      <D.28082>:
      D.28084 = mono_memberref_is_method (image, token);
      if (D.28084 == 0) goto <D.28085>; else goto <D.28086>;
      <D.28085>:
      *error = 1;
      D.28065 = 0B;
      return D.28065;
      <D.28086>:
      <D.28083>:
      init_generic_context_from_args (&context, type_args, method_args);
      method = mono_get_method_full (image, token, 0B, &context);
      D.28087 = mono_loader_get_last_error ();
      if (D.28087 != 0B) goto <D.28088>; else goto <D.28089>;
      <D.28088>:
      D.28090 = mono_loader_get_last_error ();
      D.28091 = mono_loader_error_prepare_exception (D.28090);
      mono_raise_exception (D.28091);
      <D.28089>:
      D.28065 = method;
      return D.28065;
    }
  finally
    {
      context = {CLOBBER};
    }
}


mono_memberref_is_method (struct MonoImage * image, guint32 token)
{
  unsigned int D.28094;
  unsigned int D.28095;
  struct MonoTableInfo * D.28098;
  unsigned int D.28099;
  unsigned int D.28100;
  int D.28101;
  unsigned int D.28102;
  const char * sig.130;
  const char * sig.131;
  gboolean D.28105;
  char D.28106;
  _Bool D.28107;
  void * D.28108;
  struct MonoClass * D.28111;
  struct MonoClass * handle_class.132;
  _Bool D.28113;

  D.28094 = BIT_FIELD_REF <*image, 32, 128>;
  D.28095 = D.28094 & 8;
  if (D.28095 == 0) goto <D.28096>; else goto <D.28097>;
  <D.28096>:
  {
    guint32 cols[3];
    const char * sig;

    try
      {
        D.28098 = &image->tables[10];
        D.28099 = token & 16777215;
        D.28100 = D.28099 + 4294967295;
        D.28101 = (int) D.28100;
        mono_metadata_decode_row (D.28098, D.28101, &cols, 3);
        D.28102 = cols[2];
        sig.130 = mono_metadata_blob_heap (image, D.28102);
        sig = sig.130;
        sig.131 = sig;
        mono_metadata_decode_blob_size (sig.131, &sig);
        sig.131 = sig;
        D.28106 = *sig.131;
        D.28107 = D.28106 != 6;
        D.28105 = (gboolean) D.28107;
        return D.28105;
      }
    finally
      {
        cols = {CLOBBER};
        sig = {CLOBBER};
      }
  }
  <D.28097>:
  {
    struct MonoClass * handle_class;

    try
      {
        D.28108 = mono_lookup_dynamic_token_class (image, token, 0, &handle_class, 0B);
        if (D.28108 == 0B) goto <D.28109>; else goto <D.28110>;
        <D.28109>:
        D.28105 = 0;
        return D.28105;
        <D.28110>:
        D.28111 = mono_defaults.methodhandle_class;
        handle_class.132 = handle_class;
        D.28113 = D.28111 == handle_class.132;
        D.28105 = (gboolean) D.28113;
        return D.28105;
      }
    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.28117;
  struct MonoObject * D.28120;
  struct MonoDomain * D.28121;
  struct MonoDomain * D.28124;
  struct MonoClass * D.28125;
  struct MonoDomain * D.28128;
  struct MonoClass * D.28129;
  int D.28130;
  struct MonoDomain * D.28135;
  struct MonoClass * D.28136;
  struct MonoDomain * D.28139;
  struct MonoClass * D.28140;
  int table;

  D.28117 = token >> 24;
  table = (int) D.28117;
  *error = 2;
  switch (table) <default: <D.22625>, case 1: <D.22614>, case 2: <D.22613>, case 4: <D.22620>, case 6: <D.22617>, case 10: <D.22622>, case 27: <D.22615>, case 43: <D.22618>>
  <D.22613>:
  <D.22614>:
  <D.22615>:
  {
    struct MonoType * t;

    t = ves_icall_System_Reflection_Module_ResolveTypeToken (image, token, type_args, method_args, error);
    if (t != 0B) goto <D.28118>; else goto <D.28119>;
    <D.28118>:
    D.28121 = mono_domain_get ();
    D.28120 = mono_type_get_object (D.28121, t);
    return D.28120;
    <D.28119>:
    D.28120 = 0B;
    return D.28120;
  }
  <D.22617>:
  <D.22618>:
  {
    struct MonoMethod * m;

    m = ves_icall_System_Reflection_Module_ResolveMethodToken (image, token, type_args, method_args, error);
    if (m != 0B) goto <D.28122>; else goto <D.28123>;
    <D.28122>:
    D.28124 = mono_domain_get ();
    D.28125 = m->klass;
    D.28120 = mono_method_get_object (D.28124, m, D.28125);
    return D.28120;
    <D.28123>:
    D.28120 = 0B;
    return D.28120;
  }
  <D.22620>:
  {
    struct MonoClassField * f;

    f = ves_icall_System_Reflection_Module_ResolveFieldToken (image, token, type_args, method_args, error);
    if (f != 0B) goto <D.28126>; else goto <D.28127>;
    <D.28126>:
    D.28128 = mono_domain_get ();
    D.28129 = f->parent;
    D.28120 = mono_field_get_object (D.28128, D.28129, f);
    return D.28120;
    <D.28127>:
    D.28120 = 0B;
    return D.28120;
  }
  <D.22622>:
  D.28130 = mono_memberref_is_method (image, token);
  if (D.28130 != 0) goto <D.28131>; else goto <D.28132>;
  <D.28131>:
  {
    struct MonoMethod * m;

    m = ves_icall_System_Reflection_Module_ResolveMethodToken (image, token, type_args, method_args, error);
    if (m != 0B) goto <D.28133>; else goto <D.28134>;
    <D.28133>:
    D.28135 = mono_domain_get ();
    D.28136 = m->klass;
    D.28120 = mono_method_get_object (D.28135, m, D.28136);
    return D.28120;
    <D.28134>:
    D.28120 = 0B;
    return D.28120;
  }
  <D.28132>:
  {
    struct MonoClassField * f;

    f = ves_icall_System_Reflection_Module_ResolveFieldToken (image, token, type_args, method_args, error);
    if (f != 0B) goto <D.28137>; else goto <D.28138>;
    <D.28137>:
    D.28139 = mono_domain_get ();
    D.28140 = f->parent;
    D.28120 = mono_field_get_object (D.28139, D.28140, f);
    return D.28120;
    <D.28138>:
    D.28120 = 0B;
    return D.28120;
  }
  <D.22625>:
  *error = 1;
  D.28120 = 0B;
  return D.28120;
}


ves_icall_System_Reflection_Module_ResolveFieldToken (struct MonoImage * image, guint32 token, struct MonoArray * type_args, struct MonoArray * method_args, MonoResolveTokenError * error)
{
  unsigned int D.28142;
  int token.133;
  struct MonoClassField * D.28148;
  unsigned int D.28149;
  unsigned int D.28150;
  int D.28155;
  <unnamed-unsigned:24> D.28161;
  int D.28162;
  int D.28165;
  struct MonoLoaderError * D.28168;
  struct MonoLoaderError * D.28171;
  struct MonoException * D.28172;
  struct MonoClass * klass;
  int table;
  int index;
  struct MonoGenericContext context;
  struct MonoClassField * field;

  try
    {
      D.28142 = token >> 24;
      table = (int) D.28142;
      token.133 = (int) token;
      index = token.133 & 16777215;
      *error = 2;
      if (table != 4) goto <D.28144>; else goto <D.28145>;
      <D.28144>:
      if (table != 10) goto <D.28146>; else goto <D.28147>;
      <D.28146>:
      *error = 1;
      D.28148 = 0B;
      return D.28148;
      <D.28147>:
      <D.28145>:
      D.28149 = BIT_FIELD_REF <*image, 32, 128>;
      D.28150 = D.28149 & 8;
      if (D.28150 != 0) goto <D.28151>; else goto <D.28152>;
      <D.28151>:
      if (table == 4) goto <D.28153>; else goto <D.28154>;
      <D.28153>:
      D.28148 = mono_lookup_dynamic_token_class (image, token, 0, 0B, 0B);
      return D.28148;
      <D.28154>:
      D.28155 = mono_memberref_is_method (image, token);
      if (D.28155 != 0) goto <D.28156>; else goto <D.28157>;
      <D.28156>:
      *error = 1;
      D.28148 = 0B;
      return D.28148;
      <D.28157>:
      init_generic_context_from_args (&context, type_args, method_args);
      D.28148 = mono_lookup_dynamic_token_class (image, token, 0, 0B, &context);
      return D.28148;
      <D.28152>:
      if (index <= 0) goto <D.28158>; else goto <D.28160>;
      <D.28160>:
      D.28161 = image->tables[table].rows;
      D.28162 = (int) D.28161;
      if (D.28162 < index) goto <D.28158>; else goto <D.28159>;
      <D.28158>:
      *error = 0;
      D.28148 = 0B;
      return D.28148;
      <D.28159>:
      if (table == 10) goto <D.28163>; else goto <D.28164>;
      <D.28163>:
      D.28165 = mono_memberref_is_method (image, token);
      if (D.28165 != 0) goto <D.28166>; else goto <D.28167>;
      <D.28166>:
      *error = 1;
      D.28148 = 0B;
      return D.28148;
      <D.28167>:
      <D.28164>:
      init_generic_context_from_args (&context, type_args, method_args);
      field = mono_field_from_token (image, token, &klass, &context);
      D.28168 = mono_loader_get_last_error ();
      if (D.28168 != 0B) goto <D.28169>; else goto <D.28170>;
      <D.28169>:
      D.28171 = mono_loader_get_last_error ();
      D.28172 = mono_loader_error_prepare_exception (D.28171);
      mono_raise_exception (D.28172);
      <D.28170>:
      D.28148 = field;
      return D.28148;
    }
  finally
    {
      klass = {CLOBBER};
      context = {CLOBBER};
    }
}


ves_icall_System_Reflection_Module_InternalGetTypes (struct MonoReflectionModule * module)
{
  struct MonoImage * D.28175;
  struct MonoArray * D.28178;
  struct MonoVTable * D.28179;
  struct MonoDomain * D.28180;
  struct MonoClass * D.28181;
  struct MonoArray * exceptions.134;
  unsigned int i.135;
  char * D.28184;
  unsigned int D.28187;
  struct MonoArray * exceptions;
  int i;

  try
    {
      D.28175 = module->image;
      if (D.28175 == 0B) goto <D.28176>; else goto <D.28177>;
      <D.28176>:
      D.28179 = MEM[(struct MonoObject *)module].vtable;
      D.28180 = D.28179->domain;
      D.28181 = mono_defaults.monotype_class;
      D.28178 = mono_array_new (D.28180, D.28181, 0);
      return D.28178;
      <D.28177>:
      {
        struct MonoArray * res;

        D.28179 = MEM[(struct MonoObject *)module].vtable;
        D.28180 = D.28179->domain;
        D.28175 = module->image;
        res = mono_module_get_types (D.28180, D.28175, &exceptions, 0);
        i = 0;
        goto <D.22551>;
        <D.22550>:
        {
          struct MonoException * ex;

          exceptions.134 = exceptions;
          i.135 = (unsigned int) i;
          D.28184 = mono_array_addr_with_size (exceptions.134, 4, i.135);
          ex = MEM[(struct MonoException * *)D.28184];
          if (ex != 0B) goto <D.28185>; else goto <D.28186>;
          <D.28185>:
          mono_raise_exception (ex);
          <D.28186>:
        }
        i = i + 1;
        <D.22551>:
        i.135 = (unsigned int) i;
        exceptions.134 = exceptions;
        D.28187 = mono_array_length (exceptions.134);
        if (i.135 < D.28187) goto <D.22550>; else goto <D.22552>;
        <D.22552>:
        D.28178 = res;
        return D.28178;
      }
    }
  finally
    {
      exceptions = {CLOBBER};
    }
}


mono_module_get_types (struct MonoDomain * domain, struct MonoImage * image, struct MonoArray * * exceptions, MonoBoolean exportedOnly)
{
  unsigned int D.28192;
  <unnamed-unsigned:24> D.28195;
  int D.28196;
  struct MonoClass * D.28198;
  unsigned int count.136;
  struct MonoClass * D.28200;
  struct MonoArray * D.28201;
  int D.28205;
  int D.28206;
  unsigned int D.28207;
  struct MonoType * D.28210;
  struct MonoReflectionType * D.28211;
  _Bool D.28213;
  long int D.28214;
  long int D.28215;
  struct MonoArray * D.28218;
  struct MonoLoaderError * D.28219;
  struct MonoArray * D.28222;
  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.28190>; else goto <D.28191>;
  <D.28190>:
  count = 0;
  i = 1;
  goto <D.22449>;
  <D.22448>:
  attrs = mono_metadata_decode_row_col (tdef, i, 0);
  visibility = attrs & 7;
  D.28192 = visibility + 4294967295;
  if (D.28192 <= 1) goto <D.28193>; else goto <D.28194>;
  <D.28193>:
  count = count + 1;
  <D.28194>:
  i = i + 1;
  <D.22449>:
  D.28195 = tdef->rows;
  D.28196 = (int) D.28195;
  if (D.28196 > i) goto <D.22448>; else goto <D.22450>;
  <D.22450>:
  goto <D.28197>;
  <D.28191>:
  D.28195 = tdef->rows;
  D.28196 = (int) D.28195;
  count = D.28196 + -1;
  <D.28197>:
  D.28198 = mono_defaults.monotype_class;
  count.136 = (unsigned int) count;
  res = mono_array_new (domain, D.28198, count.136);
  D.28200 = mono_defaults.exception_class;
  count.136 = (unsigned int) count;
  D.28201 = mono_array_new (domain, D.28200, count.136);
  *exceptions = D.28201;
  count = 0;
  i = 1;
  goto <D.22456>;
  <D.22455>:
  attrs = mono_metadata_decode_row_col (tdef, i, 0);
  visibility = attrs & 7;
  if (exportedOnly == 0) goto <D.28202>; else goto <D.28204>;
  <D.28204>:
  D.28192 = visibility + 4294967295;
  if (D.28192 <= 1) goto <D.28202>; else goto <D.28203>;
  <D.28202>:
  D.28205 = i + 1;
  D.28206 = D.28205 | 33554432;
  D.28207 = (unsigned int) D.28206;
  klass = mono_class_get (image, D.28207);
  if (klass != 0B) goto <D.28208>; else goto <D.28209>;
  <D.28208>:
  {
    void * * __p;

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

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

      D.28218 = *exceptions;
      count.136 = (unsigned int) count;
      __p = mono_array_addr_with_size (D.28218, 4, count.136);
      D.28218 = *exceptions;
      mono_gc_wbarrier_set_arrayref (D.28218, __p, ex);
    }
  }
  <D.28212>:
  D.28219 = mono_loader_get_last_error ();
  if (D.28219 != 0B) goto <D.28220>; else goto <D.28221>;
  <D.28220>:
  mono_loader_clear_error ();
  <D.28221>:
  count = count + 1;
  <D.28203>:
  i = i + 1;
  <D.22456>:
  D.28195 = tdef->rows;
  D.28196 = (int) D.28195;
  if (D.28196 > i) goto <D.22455>; else goto <D.22457>;
  <D.22457>:
  D.28222 = res;
  return D.28222;
}


ves_icall_System_Reflection_Module_GetPEKind (struct MonoImage * image, gint32 * pe_kind, gint32 * machine)
{
  unsigned int D.28224;
  unsigned int D.28225;
  unsigned int D.28228;
  int D.28229;
  unsigned int D.28230;
  int D.28231;
  void * D.28233;
  unsigned int D.28234;
  int D.28235;
  int D.28236;
  short unsigned int D.28237;
  int D.28238;

  D.28224 = BIT_FIELD_REF <*image, 32, 128>;
  D.28225 = D.28224 & 8;
  if (D.28225 != 0) goto <D.28226>; else goto <D.28227>;
  <D.28226>:
  {
    struct MonoDynamicImage * dyn;

    dyn = image;
    D.28228 = dyn->pe_kind;
    D.28229 = (int) D.28228;
    *pe_kind = D.28229;
    D.28230 = dyn->machine;
    D.28231 = (int) D.28230;
    *machine = D.28231;
  }
  goto <D.28232>;
  <D.28227>:
  D.28233 = image->image_info;
  D.28234 = MEM[(struct MonoCLIImageInfo *)D.28233].cli_cli_header.ch_flags;
  D.28235 = (int) D.28234;
  D.28236 = D.28235 & 3;
  *pe_kind = D.28236;
  D.28233 = image->image_info;
  D.28237 = MEM[(struct MonoCLIImageInfo *)D.28233].cli_header.coff.coff_machine;
  D.28238 = (int) D.28237;
  *machine = D.28238;
  <D.28232>:
}


ves_icall_System_Reflection_Module_GetMDStreamVersion (struct MonoImage * image)
{
  gint32 D.28239;
  short int D.28240;
  int D.28241;
  int D.28242;
  short int D.28243;
  int D.28244;

  D.28240 = image->md_version_major;
  D.28241 = (int) D.28240;
  D.28242 = D.28241 << 16;
  D.28243 = image->md_version_minor;
  D.28244 = (int) D.28243;
  D.28239 = D.28242 | D.28244;
  return D.28239;
}


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

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


ves_icall_System_Reflection_Module_GetGuidInternal (struct MonoReflectionModule * module)
{
  struct MonoVTable * D.28248;
  struct MonoImage * D.28249;
  _Bool D.28250;
  long int D.28251;
  long int D.28252;
  struct MonoString * D.28255;
  char * D.28256;
  struct MonoDomain * domain;

  D.28248 = MEM[(struct MonoObject *)module].vtable;
  domain = D.28248->domain;
  D.28249 = module->image;
  D.28250 = D.28249 == 0B;
  D.28251 = (long int) D.28250;
  D.28252 = __builtin_expect (D.28251, 0);
  if (D.28252 != 0) goto <D.28253>; else goto <D.28254>;
  <D.28253>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "icall.c", 5323, "module->image");
  <D.28254>:
  D.28249 = module->image;
  D.28256 = D.28249->guid;
  D.28255 = mono_string_new (domain, D.28256);
  return D.28255;
}


ves_icall_System_Reflection_Module_GetGlobalType (struct MonoReflectionModule * module)
{
  struct MonoVTable * D.28258;
  struct MonoImage * D.28259;
  _Bool D.28260;
  long int D.28261;
  long int D.28262;
  unsigned int D.28265;
  unsigned int D.28266;
  int D.28269;
  struct MonoReflectionType * D.28272;
  struct MonoType * D.28273;
  struct MonoDomain * domain;
  struct MonoClass * klass;

  D.28258 = MEM[(struct MonoObject *)module].vtable;
  domain = D.28258->domain;
  D.28259 = module->image;
  D.28260 = D.28259 == 0B;
  D.28261 = (long int) D.28260;
  D.28262 = __builtin_expect (D.28261, 0);
  if (D.28262 != 0) goto <D.28263>; else goto <D.28264>;
  <D.28263>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "icall.c", 5299, "module->image");
  <D.28264>:
  D.28259 = module->image;
  D.28265 = BIT_FIELD_REF <*D.28259, 32, 128>;
  D.28266 = D.28265 & 8;
  if (D.28266 != 0) goto <D.28267>; else goto <D.28268>;
  <D.28267>:
  D.28259 = module->image;
  D.28269 = MEM[(struct MonoDynamicImage *)D.28259].initial_image;
  if (D.28269 != 0) goto <D.28270>; else goto <D.28271>;
  <D.28270>:
  D.28272 = 0B;
  return D.28272;
  <D.28271>:
  <D.28268>:
  D.28259 = module->image;
  klass = mono_class_get (D.28259, 33554433);
  D.28273 = &klass->byval_arg;
  D.28272 = mono_type_get_object (domain, D.28273);
  return D.28272;
}


ves_icall_System_Reflection_Module_Close (struct MonoReflectionModule * module)
{

}


ves_icall_System_Reflection_MethodBase_GetMethodFromHandleInternalType (struct MonoMethod * method, struct MonoType * type)
{
  struct MonoClass * D.28277;
  struct MonoClass * D.28278;
  struct MonoClass * D.28279;
  struct MonoReflectionMethod * D.28282;
  struct MonoDomain * D.28288;
  struct MonoClass * klass;

  if (type != 0B) goto <D.28275>; else goto <D.28276>;
  <D.28275>:
  klass = mono_class_from_mono_type (type);
  D.28277 = method->klass;
  D.28278 = mono_class_get_generic_type_definition (D.28277);
  D.28279 = mono_class_get_generic_type_definition (klass);
  if (D.28278 != D.28279) goto <D.28280>; else goto <D.28281>;
  <D.28280>:
  D.28282 = 0B;
  return D.28282;
  <D.28281>:
  D.28277 = method->klass;
  if (D.28277 != klass) goto <D.28283>; else goto <D.28284>;
  <D.28283>:
  method = mono_method_get_equivalent_method (method, klass);
  if (method == 0B) goto <D.28285>; else goto <D.28286>;
  <D.28285>:
  D.28282 = 0B;
  return D.28282;
  <D.28286>:
  <D.28284>:
  goto <D.28287>;
  <D.28276>:
  klass = method->klass;
  <D.28287>:
  D.28288 = mono_domain_get ();
  D.28282 = mono_method_get_object (D.28288, method, klass);
  return D.28282;
}


mono_method_get_equivalent_method (struct MonoMethod * method, struct MonoClass * klass)
{
  unsigned int D.28290;
  unsigned int D.28291;
  struct MonoGenericInst * D.28294;
  struct MonoGenericInst * D.28297;
  struct MonoGenericInst * D.28298;
  struct MonoGenericClass * D.28299;
  struct MonoGenericInst * D.28302;
  struct MonoGenericContainer * D.28304;
  struct MonoGenericInst * D.28307;
  struct MonoMethod * D.28308;
  struct MonoMethod * D.28309;
  struct MonoClass * D.28310;
  unsigned char D.28311;
  struct MonoMethod * * D.28314;
  unsigned int i.137;
  unsigned int D.28316;
  struct MonoMethod * * D.28317;
  struct MonoMethod * D.28318;
  unsigned int i.138;
  unsigned int D.28322;
  unsigned char D.28323;
  int iftmp.139;
  unsigned int offset.140;
  unsigned int D.28332;
  _Bool D.28333;
  long int D.28334;
  long int D.28335;
  struct MonoMethod * * D.28338;
  unsigned int offset.141;
  unsigned int D.28340;
  struct MonoMethod * * D.28341;
  int offset;
  int i;

  offset = -1;
  D.28290 = BIT_FIELD_REF <*method, 32, 160>;
  D.28291 = D.28290 & 4096;
  if (D.28291 != 0) goto <D.28292>; else goto <D.28293>;
  <D.28292>:
  D.28294 = MEM[(struct MonoMethodInflated *)method].context.method_inst;
  if (D.28294 != 0B) goto <D.28295>; else goto <D.28296>;
  <D.28295>:
  {
    struct MonoMethodInflated * inflated;
    struct MonoGenericContext ctx;

    try
      {
        inflated = method;
        D.28297 = inflated->context.method_inst;
        ctx.method_inst = D.28297;
        D.28298 = inflated->context.class_inst;
        ctx.class_inst = D.28298;
        D.28299 = klass->generic_class;
        if (D.28299 != 0B) goto <D.28300>; else goto <D.28301>;
        <D.28300>:
        D.28299 = klass->generic_class;
        D.28302 = D.28299->context.class_inst;
        ctx.class_inst = D.28302;
        goto <D.28303>;
        <D.28301>:
        D.28304 = klass->generic_container;
        if (D.28304 != 0B) goto <D.28305>; else goto <D.28306>;
        <D.28305>:
        D.28304 = klass->generic_container;
        D.28307 = D.28304->context.class_inst;
        ctx.class_inst = D.28307;
        <D.28306>:
        <D.28303>:
        D.28309 = inflated->declaring;
        D.28308 = mono_class_inflate_generic_method_full (D.28309, klass, &ctx);
        return D.28308;
      }
    finally
      {
        ctx = {CLOBBER};
      }
  }
  <D.28296>:
  <D.28293>:
  D.28310 = method->klass;
  mono_class_setup_methods (D.28310);
  D.28310 = method->klass;
  D.28311 = D.28310->exception_type;
  if (D.28311 != 0) goto <D.28312>; else goto <D.28313>;
  <D.28312>:
  D.28308 = 0B;
  return D.28308;
  <D.28313>:
  i = 0;
  goto <D.22338>;
  <D.22337>:
  D.28310 = method->klass;
  D.28314 = D.28310->methods;
  i.137 = (unsigned int) i;
  D.28316 = i.137 * 4;
  D.28317 = D.28314 + D.28316;
  D.28318 = *D.28317;
  if (D.28318 == method) goto <D.28319>; else goto <D.28320>;
  <D.28319>:
  offset = i;
  goto <D.22336>;
  <D.28320>:
  i = i + 1;
  <D.22338>:
  i.138 = (unsigned int) i;
  D.28310 = method->klass;
  D.28322 = D.28310->method.count;
  if (i.138 < D.28322) goto <D.22337>; else goto <D.22336>;
  <D.22336>:
  mono_class_setup_methods (klass);
  D.28323 = klass->exception_type;
  if (D.28323 != 0) goto <D.28324>; else goto <D.28325>;
  <D.28324>:
  D.28308 = 0B;
  return D.28308;
  <D.28325>:
  if (offset < 0) goto <D.28327>; else goto <D.28330>;
  <D.28330>:
  offset.140 = (unsigned int) offset;
  D.28332 = klass->method.count;
  if (offset.140 >= D.28332) goto <D.28327>; else goto <D.28328>;
  <D.28327>:
  iftmp.139 = 1;
  goto <D.28329>;
  <D.28328>:
  iftmp.139 = 0;
  <D.28329>:
  D.28333 = iftmp.139 != 0;
  D.28334 = (long int) D.28333;
  D.28335 = __builtin_expect (D.28334, 0);
  if (D.28335 != 0) goto <D.28336>; else goto <D.28337>;
  <D.28336>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "icall.c", 4779, "offset >= 0 && offset < klass->method.count");
  <D.28337>:
  D.28338 = klass->methods;
  offset.141 = (unsigned int) offset;
  D.28340 = offset.141 * 4;
  D.28341 = D.28338 + D.28340;
  D.28308 = *D.28341;
  return D.28308;
}


ves_icall_System_Reflection_MethodBase_GetMethodFromHandleInternal (struct MonoMethod * method)
{
  struct MonoReflectionMethod * D.28344;
  struct MonoDomain * D.28345;

  D.28345 = mono_domain_get ();
  D.28344 = mono_method_get_object (D.28345, method, 0B);
  return D.28344;
}


ves_icall_System_Reflection_MethodBase_GetMethodBodyInternal (struct MonoMethod * method)
{
  struct MonoReflectionMethodBody * D.28347;
  struct MonoDomain * D.28348;

  D.28348 = mono_domain_get ();
  D.28347 = mono_method_body_get_object (D.28348, method);
  return D.28347;
}


ves_icall_GetCurrentMethod ()
{
  unsigned int D.28350;
  unsigned int D.28351;
  struct MonoReflectionMethod * D.28352;
  struct MonoDomain * D.28353;
  struct MonoMethod * m;

  m = mono_method_get_last_managed ();
  goto <D.22326>;
  <D.22325>:
  m = MEM[(struct MonoMethodInflated *)m].declaring;
  <D.22326>:
  D.28350 = BIT_FIELD_REF <*m, 32, 160>;
  D.28351 = D.28350 & 4096;
  if (D.28351 != 0) goto <D.22325>; else goto <D.22327>;
  <D.22327>:
  D.28353 = mono_domain_get ();
  D.28352 = mono_method_get_object (D.28353, m, 0B);
  return D.28352;
}


ves_icall_System_Reflection_FieldInfo_internal_from_handle_type (struct MonoClassField * handle, struct MonoType * type)
{
  _Bool D.28355;
  long int D.28356;
  long int D.28357;
  struct MonoClass * D.28363;
  struct MonoReflectionField * D.28368;
  struct MonoDomain * D.28369;
  gboolean found;
  struct MonoClass * klass;
  struct MonoClass * k;

  found = 0;
  D.28355 = handle == 0B;
  D.28356 = (long int) D.28355;
  D.28357 = __builtin_expect (D.28356, 0);
  if (D.28357 != 0) goto <D.28358>; else goto <D.28359>;
  <D.28358>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "icall.c", 1637, "handle");
  <D.28359>:
  if (type == 0B) goto <D.28360>; else goto <D.28361>;
  <D.28360>:
  klass = handle->parent;
  goto <D.28362>;
  <D.28361>:
  klass = mono_class_from_mono_type (type);
  k = klass;
  goto <D.21015>;
  <D.21014>:
  D.28363 = handle->parent;
  if (D.28363 == k) goto <D.28364>; else goto <D.28365>;
  <D.28364>:
  found = 1;
  goto <D.21013>;
  <D.28365>:
  k = k->parent;
  <D.21015>:
  if (k != 0B) goto <D.21014>; else goto <D.21013>;
  <D.21013>:
  if (found == 0) goto <D.28366>; else goto <D.28367>;
  <D.28366>:
  D.28368 = 0B;
  return D.28368;
  <D.28367>:
  <D.28362>:
  D.28369 = mono_domain_get ();
  D.28368 = mono_field_get_object (D.28369, klass, handle);
  return D.28368;
}


ves_icall_System_Reflection_FieldInfo_get_marshal_info (struct MonoReflectionField * field)
{
  struct MonoClassField * D.28371;
  struct MonoGenericContainer * D.28374;
  struct MonoGenericClass * D.28376;
  struct MonoGenericInst * D.28378;
  unsigned int D.28379;
  unsigned int D.28380;
  struct MonoReflectionMarshalAsAttribute * D.28381;
  struct MonoClassField * D.28382;
  struct MonoMarshalSpec * D.28385;
  struct MonoVTable * D.28388;
  struct MonoDomain * D.28389;
  unsigned int i.142;
  unsigned int D.28391;
  struct MonoClass * klass;
  struct MonoMarshalType * info;
  int i;

  D.28371 = field->field;
  klass = D.28371->parent;
  D.28374 = klass->generic_container;
  if (D.28374 != 0B) goto <D.28372>; else goto <D.28375>;
  <D.28375>:
  D.28376 = klass->generic_class;
  if (D.28376 != 0B) goto <D.28377>; else goto <D.28373>;
  <D.28377>:
  D.28376 = klass->generic_class;
  D.28378 = D.28376->context.class_inst;
  D.28379 = BIT_FIELD_REF <*D.28378, 32, 32>;
  D.28380 = D.28379 & 4194304;
  if (D.28380 != 0) goto <D.28372>; else goto <D.28373>;
  <D.28372>:
  D.28381 = 0B;
  return D.28381;
  <D.28373>:
  info = mono_marshal_load_type_info (klass);
  i = 0;
  goto <D.21004>;
  <D.21003>:
  D.28382 = info->fields[i].field;
  D.28371 = field->field;
  if (D.28382 == D.28371) goto <D.28383>; else goto <D.28384>;
  <D.28383>:
  D.28385 = info->fields[i].mspec;
  if (D.28385 == 0B) goto <D.28386>; else goto <D.28387>;
  <D.28386>:
  D.28381 = 0B;
  return D.28381;
  <D.28387>:
  D.28388 = field->object.vtable;
  D.28389 = D.28388->domain;
  D.28385 = info->fields[i].mspec;
  D.28381 = mono_reflection_marshal_as_attribute_from_marshal_spec (D.28389, klass, D.28385);
  return D.28381;
  <D.28384>:
  i = i + 1;
  <D.21004>:
  i.142 = (unsigned int) i;
  D.28391 = info->num_fields;
  if (i.142 < D.28391) goto <D.21003>; else goto <D.21005>;
  <D.21005>:
  D.28381 = 0B;
  return D.28381;
}


ves_icall_System_Reflection_FieldInfo_GetTypeModifiers (struct MonoReflectionField * field, MonoBoolean optional)
{
  struct MonoClassField * D.28393;
  int D.28394;
  struct MonoArray * D.28397;
  struct MonoClass * D.28398;
  struct MonoImage * D.28399;
  int D.28400;
  struct MonoError error;
  struct MonoType * type;

  try
    {
      D.28393 = field->field;
      type = mono_field_get_type_checked (D.28393, &error);
      D.28394 = mono_error_ok (&error);
      if (D.28394 == 0) goto <D.28395>; else goto <D.28396>;
      <D.28395>:
      mono_error_raise_exception (&error);
      <D.28396>:
      D.28393 = field->field;
      D.28398 = D.28393->parent;
      D.28399 = D.28398->image;
      D.28400 = (int) optional;
      D.28397 = type_array_from_modifiers (D.28399, type, D.28400);
      return D.28397;
    }
  finally
    {
      error = {CLOBBER};
    }
}


ves_icall_TypeBuilder_get_IsGenericParameter (struct MonoReflectionTypeBuilder * tb)
{
  MonoBoolean D.28403;
  struct MonoType * D.28404;

  D.28404 = tb->type.type;
  D.28403 = is_generic_parameter (D.28404);
  return D.28403;
}


ves_icall_ModuleBuilder_getToken (struct MonoReflectionModuleBuilder * mb, struct MonoObject * obj, gboolean create_open_instance)
{
  _Bool D.28406;
  long int D.28407;
  long int D.28408;
  gint32 D.28413;
  struct MonoDynamicImage * D.28414;
  unsigned int D.28415;

  D.28406 = obj == 0B;
  D.28407 = (long int) D.28406;
  D.28408 = __builtin_expect (D.28407, 0);
  if (D.28408 != 0) goto <D.28409>; else goto <D.28410>;
  <D.28409>:
  {
    struct MonoException * ex;

    if (obj != 0B) goto <D.28411>; else goto <D.28412>;
    <D.28411>:
    <D.28412>:
    ex = mono_get_exception_argument_null ("obj");
    mono_raise_exception (ex);
  }
  <D.28410>:
  D.28414 = mb->dynamic_image;
  D.28415 = mono_image_create_token (D.28414, obj, create_open_instance, 1);
  D.28413 = (gint32) D.28415;
  return D.28413;
}


ves_icall_ModuleBuilder_getMethodToken (struct MonoReflectionModuleBuilder * mb, struct MonoReflectionMethod * method, struct MonoArray * opt_param_types)
{
  _Bool D.28417;
  long int D.28418;
  long int D.28419;
  gint32 D.28424;
  struct MonoDynamicImage * D.28425;
  unsigned int D.28426;

  D.28417 = method == 0B;
  D.28418 = (long int) D.28417;
  D.28419 = __builtin_expect (D.28418, 0);
  if (D.28419 != 0) goto <D.28420>; else goto <D.28421>;
  <D.28420>:
  {
    struct MonoException * ex;

    if (method != 0B) goto <D.28422>; else goto <D.28423>;
    <D.28422>:
    <D.28423>:
    ex = mono_get_exception_argument_null ("method");
    mono_raise_exception (ex);
  }
  <D.28421>:
  D.28425 = mb->dynamic_image;
  D.28426 = mono_image_create_method_token (D.28425, method, opt_param_types);
  D.28424 = (gint32) D.28426;
  return D.28424;
}


ves_icall_ModuleBuilder_create_modified_type (struct MonoReflectionTypeBuilder * tb, struct MonoString * smodifiers)
{
  struct MonoType * D.28428;
  char D.28429;
  int D.28430;
  struct MonoReflectionType * D.28433;
  struct MonoVTable * D.28434;
  struct MonoDomain * D.28435;
  struct MonoType * D.28436;
  struct MonoType * D.28437;
  unsigned int rank.143;
  struct MonoClass * klass;
  int isbyref;
  int rank;
  char * str;
  char * p;

  isbyref = 0;
  str = mono_string_to_utf8 (smodifiers);
  D.28428 = tb->type.type;
  klass = mono_class_from_mono_type (D.28428);
  p = str;
  goto <D.22656>;
  <D.22655>:
  D.28429 = *p;
  D.28430 = (int) D.28429;
  switch (D.28430) <default: <D.22654>, case 38: <D.22647>, case 42: <D.22648>, case 91: <D.22650>>
  <D.22647>:
  if (isbyref != 0) goto <D.28431>; else goto <D.28432>;
  <D.28431>:
  monoeg_g_free (str);
  D.28433 = 0B;
  return D.28433;
  <D.28432>:
  isbyref = 1;
  p = p + 1;
  monoeg_g_free (str);
  D.28434 = MEM[(struct MonoObject *)tb].vtable;
  D.28435 = D.28434->domain;
  D.28436 = &klass->this_arg;
  D.28433 = mono_type_get_object (D.28435, D.28436);
  return D.28433;
  <D.22648>:
  D.28437 = &klass->byval_arg;
  klass = mono_ptr_class_get (D.28437);
  mono_class_init (klass);
  p = p + 1;
  goto <D.22649>;
  <D.22650>:
  rank = 1;
  p = p + 1;
  goto <D.22653>;
  <D.22652>:
  D.28429 = *p;
  if (D.28429 == 93) goto <D.22651>; else goto <D.28438>;
  <D.28438>:
  D.28429 = *p;
  if (D.28429 == 44) goto <D.28439>; else goto <D.28440>;
  <D.28439>:
  rank = rank + 1;
  goto <D.28441>;
  <D.28440>:
  D.28429 = *p;
  if (D.28429 != 42) goto <D.28442>; else goto <D.28443>;
  <D.28442>:
  monoeg_g_free (str);
  D.28433 = 0B;
  return D.28433;
  <D.28443>:
  <D.28441>:
  p = p + 1;
  <D.22653>:
  D.28429 = *p;
  if (D.28429 != 0) goto <D.22652>; else goto <D.22651>;
  <D.22651>:
  D.28429 = *p;
  if (D.28429 != 93) goto <D.28444>; else goto <D.28445>;
  <D.28444>:
  monoeg_g_free (str);
  D.28433 = 0B;
  return D.28433;
  <D.28445>:
  p = p + 1;
  rank.143 = (unsigned int) rank;
  klass = mono_array_class_get (klass, rank.143);
  mono_class_init (klass);
  goto <D.22649>;
  <D.22654>:
  goto <D.22649>;
  <D.22649>:
  <D.22656>:
  D.28429 = *p;
  if (D.28429 != 0) goto <D.22655>; else goto <D.22657>;
  <D.22657>:
  monoeg_g_free (str);
  D.28434 = MEM[(struct MonoObject *)tb].vtable;
  D.28435 = D.28434->domain;
  D.28437 = &klass->byval_arg;
  D.28433 = mono_type_get_object (D.28435, D.28437);
  return D.28433;
}


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

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


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

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


ves_icall_System_Reflection_AssemblyName_ParseName (struct MonoReflectionAssemblyName * name, struct MonoString * assname)
{
  struct MonoVTable * D.28451;
  int D.28452;
  const mono_byte * D.28455;
  gboolean D.28456;
  int is_version_defined.144;
  int is_token_defined.145;
  struct MonoAssemblyName aname;
  struct MonoDomain * domain;
  char * val;
  gboolean is_version_defined;
  gboolean is_token_defined;

  try
    {
      D.28451 = MEM[(struct MonoObject *)name].vtable;
      domain = D.28451->domain;
      aname.public_key = 0B;
      val = mono_string_to_utf8 (assname);
      D.28452 = mono_assembly_name_parse_full (val, &aname, 1, &is_version_defined, &is_token_defined);
      if (D.28452 == 0) goto <D.28453>; else goto <D.28454>;
      <D.28453>:
      D.28455 = aname.public_key;
      monoeg_g_free (D.28455);
      monoeg_g_free (val);
      D.28456 = 0;
      return D.28456;
      <D.28454>:
      is_version_defined.144 = is_version_defined;
      is_token_defined.145 = is_token_defined;
      fill_reflection_assembly_name (domain, name, &aname, "", is_version_defined.144, 0, is_token_defined.145);
      mono_assembly_name_free (&aname);
      D.28455 = aname.public_key;
      monoeg_g_free (D.28455);
      monoeg_g_free (val);
      D.28456 = 1;
      return D.28456;
    }
  finally
    {
      aname = {CLOBBER};
      is_version_defined = {CLOBBER};
      is_token_defined = {CLOBBER};
    }
}


fill_reflection_assembly_name (struct MonoDomain * domain, struct MonoReflectionAssemblyName * aname, struct MonoAssemblyName * name, const char * absolute, gboolean by_default_version, gboolean default_publickey, gboolean default_token)
{
  struct MonoString * * D.28461;
  const char * D.28462;
  struct MonoString * D.28463;
  short unsigned int D.28464;
  int D.28465;
  short unsigned int D.28466;
  int D.28467;
  short unsigned int D.28468;
  int D.28469;
  unsigned int D.28470;
  short unsigned int D.28471;
  int D.28472;
  unsigned int D.28473;
  short unsigned int D.28474;
  unsigned int D.28475;
  struct MonoObject * * D.28478;
  unsigned int D.28479;
  unsigned int D.28480;
  unsigned int D.28481;
  unsigned int D.28482;
  struct MonoObject * D.28483;
  char D.28486;
  struct MonoString * * D.28491;
  struct MonoString * D.28492;
  struct MonoMethod * create_culture.146;
  struct MonoImage * D.28496;
  struct MonoMethod * create_culture.147;
  _Bool D.28498;
  long int D.28499;
  long int D.28500;
  const char * D.28503;
  struct MonoString * D.28506;
  struct MonoObject * * D.28507;
  struct MonoObject * D.28508;
  const mono_byte * pkey_ptr.148;
  const char * pkey_ptr.149;
  struct MonoArray * * D.28513;
  struct MonoClass * D.28514;
  struct MonoArray * D.28515;
  struct MonoArray * D.28516;
  char * D.28517;
  unsigned int D.28518;
  unsigned int D.28519;
  struct MonoArray * D.28523;
  unsigned char D.28524;
  struct MonoArray * * D.28527;
  struct MonoArray * D.28528;
  struct MonoArray * D.28529;
  int j.150;
  unsigned char D.28531;
  char D.28532;
  int D.28533;
  int D.28534;
  int D.28535;
  char D.28536;
  int j.151;
  unsigned char D.28538;
  char D.28539;
  int D.28540;
  int D.28541;
  char D.28542;
  char D.28543;
  char D.28544;
  struct MonoArray * D.28548;
  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.28461 = &aname->name;
      D.28462 = name->name;
      D.28463 = mono_string_new (domain, D.28462);
      mono_gc_wbarrier_set_field (aname, D.28461, D.28463);
      D.28464 = name->major;
      D.28465 = (int) D.28464;
      aname->major = D.28465;
      D.28466 = name->minor;
      D.28467 = (int) D.28466;
      aname->minor = D.28467;
      D.28468 = name->build;
      D.28469 = (int) D.28468;
      aname->build = D.28469;
      D.28470 = name->flags;
      aname->flags = D.28470;
      D.28471 = name->revision;
      D.28472 = (int) D.28471;
      aname->revision = D.28472;
      D.28473 = name->hash_alg;
      aname->hashalg = D.28473;
      aname->versioncompat = 1;
      D.28474 = name->arch;
      D.28475 = (unsigned int) D.28474;
      aname->processor_architecture = D.28475;
      if (by_default_version != 0) goto <D.28476>; else goto <D.28477>;
      <D.28476>:
      D.28478 = &aname->version;
      D.28464 = name->major;
      D.28479 = (unsigned int) D.28464;
      D.28466 = name->minor;
      D.28480 = (unsigned int) D.28466;
      D.28468 = name->build;
      D.28481 = (unsigned int) D.28468;
      D.28471 = name->revision;
      D.28482 = (unsigned int) D.28471;
      D.28483 = create_version (domain, D.28479, D.28480, D.28481, D.28482);
      mono_gc_wbarrier_set_field (aname, D.28478, D.28483);
      <D.28477>:
      codebase = 0B;
      if (absolute != 0B) goto <D.28484>; else goto <D.28485>;
      <D.28484>:
      D.28486 = *absolute;
      if (D.28486 != 0) goto <D.28487>; else goto <D.28488>;
      <D.28487>:
      {
        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.28488>:
      <D.28485>:
      if (codebase != 0B) goto <D.28489>; else goto <D.28490>;
      <D.28489>:
      D.28491 = &aname->codebase;
      D.28492 = mono_string_new (domain, codebase);
      mono_gc_wbarrier_set_field (aname, D.28491, D.28492);
      monoeg_g_free (codebase);
      <D.28490>:
      create_culture.146 = create_culture;
      if (create_culture.146 == 0B) goto <D.28494>; else goto <D.28495>;
      <D.28494>:
      {
        struct MonoMethodDesc * desc;

        desc = mono_method_desc_new ("System.Globalization.CultureInfo:CreateCulture(string,bool)", 1);
        D.28496 = mono_defaults.corlib;
        create_culture.147 = mono_method_desc_search_in_image (desc, D.28496);
        create_culture = create_culture.147;
        create_culture.146 = create_culture;
        D.28498 = create_culture.146 == 0B;
        D.28499 = (long int) D.28498;
        D.28500 = __builtin_expect (D.28499, 0);
        if (D.28500 != 0) goto <D.28501>; else goto <D.28502>;
        <D.28501>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "icall.c", 4954, "create_culture");
        <D.28502>:
        mono_method_desc_free (desc);
      }
      <D.28495>:
      D.28503 = name->culture;
      if (D.28503 != 0B) goto <D.28504>; else goto <D.28505>;
      <D.28504>:
      D.28503 = name->culture;
      D.28506 = mono_string_new (domain, D.28503);
      args[0] = D.28506;
      args[1] = &assembly_ref;
      D.28507 = &aname->cultureInfo;
      create_culture.146 = create_culture;
      D.28508 = mono_runtime_invoke (create_culture.146, 0B, &args, 0B);
      mono_gc_wbarrier_set_field (aname, D.28507, D.28508);
      <D.28505>:
      pkey_ptr.148 = name->public_key;
      if (pkey_ptr.148 != 0B) goto <D.28510>; else goto <D.28511>;
      <D.28510>:
      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.28513 = &aname->publicKey;
      D.28514 = mono_defaults.byte_class;
      D.28515 = mono_array_new (domain, D.28514, pkey_len);
      mono_gc_wbarrier_set_field (aname, D.28513, D.28515);
      D.28516 = aname->publicKey;
      D.28517 = mono_array_addr_with_size (D.28516, 1, 0);
      pkey_ptr.149 = pkey_ptr;
      memcpy (D.28517, pkey_ptr.149, pkey_len);
      D.28518 = aname->flags;
      D.28519 = D.28518 | 1;
      aname->flags = D.28519;
      goto <D.28520>;
      <D.28511>:
      if (default_publickey != 0) goto <D.28521>; else goto <D.28522>;
      <D.28521>:
      D.28513 = &aname->publicKey;
      D.28514 = mono_defaults.byte_class;
      D.28523 = mono_array_new (domain, D.28514, 0);
      mono_gc_wbarrier_set_field (aname, D.28513, D.28523);
      D.28518 = aname->flags;
      D.28519 = D.28518 | 1;
      aname->flags = D.28519;
      <D.28522>:
      <D.28520>:
      D.28524 = name->public_key_token[0];
      if (D.28524 != 0) goto <D.28525>; else goto <D.28526>;
      <D.28525>:
      {
        int i;
        int j;
        char * p;

        D.28527 = &aname->keyToken;
        D.28514 = mono_defaults.byte_class;
        D.28528 = mono_array_new (domain, D.28514, 8);
        mono_gc_wbarrier_set_field (aname, D.28527, D.28528);
        D.28529 = aname->keyToken;
        p = mono_array_addr_with_size (D.28529, 1, 0);
        i = 0;
        j = 0;
        goto <D.22398>;
        <D.22397>:
        j.150 = j;
        j = j.150 + 1;
        D.28531 = name->public_key_token[j.150];
        D.28532 = (char) D.28531;
        D.28533 = (int) D.28532;
        D.28534 = monoeg_g_ascii_xdigit_value (D.28533);
        D.28535 = D.28534 << 4;
        D.28536 = (char) D.28535;
        *p = D.28536;
        j.151 = j;
        j = j.151 + 1;
        D.28538 = name->public_key_token[j.151];
        D.28539 = (char) D.28538;
        D.28540 = (int) D.28539;
        D.28541 = monoeg_g_ascii_xdigit_value (D.28540);
        D.28542 = *p;
        D.28543 = (char) D.28541;
        D.28544 = D.28542 | D.28543;
        *p = D.28544;
        p = p + 1;
        i = i + 1;
        <D.22398>:
        if (i <= 7) goto <D.22397>; else goto <D.22399>;
        <D.22399>:
      }
      goto <D.28545>;
      <D.28526>:
      if (default_token != 0) goto <D.28546>; else goto <D.28547>;
      <D.28546>:
      D.28527 = &aname->keyToken;
      D.28514 = mono_defaults.byte_class;
      D.28548 = mono_array_new (domain, D.28514, 0);
      mono_gc_wbarrier_set_field (aname, D.28527, D.28548);
      <D.28547>:
      <D.28545>:
    }
  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.28552;
  struct MonoClass * System_Version.153;
  _Bool D.28554;
  long int D.28555;
  long int D.28556;
  struct MonoMethod * create_version.154;
  struct MonoMethod * create_version.155;
  _Bool D.28563;
  long int D.28564;
  long int D.28565;
  struct MonoObject * D.28568;
  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.28550>; else goto <D.28551>;
      <D.28550>:
      D.28552 = mono_defaults.corlib;
      System_Version.153 = mono_class_from_name (D.28552, "System", "Version");
      System_Version = System_Version.153;
      System_Version.152 = System_Version;
      D.28554 = System_Version.152 == 0B;
      D.28555 = (long int) D.28554;
      D.28556 = __builtin_expect (D.28555, 0);
      if (D.28556 != 0) goto <D.28557>; else goto <D.28558>;
      <D.28557>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "icall.c", 4404, "System_Version");
      <D.28558>:
      <D.28551>:
      create_version.154 = create_version;
      if (create_version.154 == 0B) goto <D.28560>; else goto <D.28561>;
      <D.28560>:
      {
        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.28563 = create_version.154 == 0B;
        D.28564 = (long int) D.28563;
        D.28565 = __builtin_expect (D.28564, 0);
        if (D.28565 != 0) goto <D.28566>; else goto <D.28567>;
        <D.28566>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "icall.c", 4410, "create_version");
        <D.28567>:
        mono_method_desc_free (desc);
      }
      <D.28561>:
      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.28568 = result;
      return D.28568;
    }
  finally
    {
      args = {CLOBBER};
    }
}


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


ves_icall_System_Reflection_Assembly_get_location (struct MonoReflectionAssembly * assembly)
{
  struct MonoVTable * D.28577;
  struct MonoAssembly * D.28578;
  struct MonoImage * D.28579;
  const char * D.28580;
  struct MonoString * D.28581;
  struct MonoDomain * domain;
  struct MonoString * res;

  D.28577 = MEM[(struct MonoObject *)assembly].vtable;
  domain = D.28577->domain;
  D.28578 = assembly->assembly;
  D.28579 = D.28578->image;
  D.28580 = mono_image_get_filename (D.28579);
  res = mono_string_new (domain, D.28580);
  D.28581 = res;
  return D.28581;
}


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

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


ves_icall_System_Reflection_Assembly_get_fullName (struct MonoReflectionAssembly * assembly)
{
  struct MonoVTable * D.28585;
  struct MonoAssemblyName * D.28586;
  struct MonoString * D.28587;
  struct MonoDomain * domain;
  struct MonoAssembly * mass;
  struct MonoString * res;
  gchar * name;

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


ves_icall_System_Reflection_Assembly_get_code_base (struct MonoReflectionAssembly * assembly, MonoBoolean escaped)
{
  struct MonoVTable * D.28589;
  struct MonoImage * D.28590;
  char * D.28591;
  int D.28592;
  gchar * absolute.156;
  gchar * absolute.157;
  char * D.28598;
  gchar * absolute.158;
  struct MonoString * D.28605;
  struct MonoDomain * domain;
  struct MonoAssembly * mass;
  struct MonoString * res;
  gchar * uri;
  gchar * absolute;
  gchar * dirname;

  try
    {
      D.28589 = MEM[(struct MonoObject *)assembly].vtable;
      domain = D.28589->domain;
      mass = assembly->assembly;
      res = 0B;
      D.28590 = mass->image;
      D.28591 = D.28590->name;
      D.28592 = monoeg_g_path_is_absolute (D.28591);
      if (D.28592 != 0) goto <D.28593>; else goto <D.28594>;
      <D.28593>:
      D.28590 = mass->image;
      D.28591 = D.28590->name;
      absolute.156 = monoeg_strdup (D.28591);
      absolute = absolute.156;
      absolute.157 = absolute;
      dirname = monoeg_g_path_get_dirname (absolute.157);
      goto <D.28597>;
      <D.28594>:
      D.28598 = mass->basedir;
      D.28590 = mass->image;
      D.28591 = D.28590->name;
      absolute.158 = monoeg_g_build_path ("/", D.28598, D.28591, 0B);
      absolute = absolute.158;
      D.28598 = mass->basedir;
      dirname = monoeg_strdup (D.28598);
      <D.28597>:
      replace_shadow_path (domain, dirname, &absolute);
      monoeg_g_free (dirname);
      if (escaped != 0) goto <D.28600>; else goto <D.28601>;
      <D.28600>:
      absolute.157 = absolute;
      uri = monoeg_g_filename_to_uri (absolute.157, 0B, 0B);
      goto <D.28602>;
      <D.28601>:
      {
        const char * prepend;

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


replace_shadow_path (struct MonoDomain * domain, gchar * dirname, gchar * * filename)
{
  int D.28608;
  int D.28613;
  gchar * content.159;
  int D.28616;
  gchar * D.28621;
  gboolean D.28624;
  gchar * content;
  gchar * shadow_ini_file;
  gsize len;

  try
    {
      D.28608 = mono_is_shadow_copy_enabled (domain, dirname);
      if (D.28608 != 0) goto <D.28609>; else goto <D.28610>;
      <D.28609>:
      shadow_ini_file = monoeg_g_build_path ("/", dirname, "__AssemblyInfo__.ini", 0B);
      content = 0B;
      D.28613 = monoeg_g_file_get_contents (shadow_ini_file, &content, &len, 0B);
      if (D.28613 == 0) goto <D.28611>; else goto <D.28614>;
      <D.28614>:
      content.159 = content;
      D.28616 = monoeg_g_file_test (content.159, 1);
      if (D.28616 == 0) goto <D.28611>; else goto <D.28612>;
      <D.28611>:
      content.159 = content;
      if (content.159 != 0B) goto <D.28617>; else goto <D.28618>;
      <D.28617>:
      content.159 = content;
      monoeg_g_free (content.159);
      content = 0B;
      <D.28618>:
      <D.28612>:
      monoeg_g_free (shadow_ini_file);
      content.159 = content;
      if (content.159 != 0B) goto <D.28619>; else goto <D.28620>;
      <D.28619>:
      D.28621 = *filename;
      if (D.28621 != 0B) goto <D.28622>; else goto <D.28623>;
      <D.28622>:
      D.28621 = *filename;
      monoeg_g_free (D.28621);
      <D.28623>:
      content.159 = content;
      *filename = content.159;
      D.28624 = 1;
      return D.28624;
      <D.28620>:
      <D.28610>:
      D.28624 = 0;
      return D.28624;
    }
  finally
    {
      content = {CLOBBER};
      len = {CLOBBER};
    }
}


ves_icall_System_Reflection_Assembly_get_ReflectionOnly (struct MonoReflectionAssembly * assembly)
{
  MonoBoolean D.28627;
  struct MonoAssembly * D.28628;
  int D.28629;

  D.28628 = assembly->assembly;
  D.28629 = D.28628->ref_only;
  D.28627 = (MonoBoolean) D.28629;
  return D.28627;
}


ves_icall_System_Reflection_Assembly_get_EntryPoint (struct MonoReflectionAssembly * assembly)
{
  struct MonoAssembly * D.28631;
  struct MonoImage * D.28632;
  struct MonoReflectionMethod * D.28635;
  struct MonoVTable * D.28636;
  struct MonoDomain * D.28637;
  struct MonoMethod * D.28638;
  guint32 token;

  D.28631 = assembly->assembly;
  D.28632 = D.28631->image;
  token = mono_image_get_entry_point (D.28632);
  if (token == 0) goto <D.28633>; else goto <D.28634>;
  <D.28633>:
  D.28635 = 0B;
  return D.28635;
  <D.28634>:
  D.28636 = MEM[(struct MonoObject *)assembly].vtable;
  D.28637 = D.28636->domain;
  D.28631 = assembly->assembly;
  D.28632 = D.28631->image;
  D.28638 = mono_get_method (D.28632, token, 0B);
  D.28635 = mono_method_get_object (D.28637, D.28638, 0B);
  return D.28635;
}


ves_icall_MonoDebugger_GetMethodToken (struct MonoReflectionMethod * method)
{
  gint32 D.28640;
  struct MonoMethod * D.28641;
  unsigned int D.28642;

  D.28641 = method->method;
  D.28642 = D.28641->token;
  D.28640 = (gint32) D.28642;
  return D.28640;
}


ves_icall_System_Reflection_Assembly_LoadPermissions (struct MonoReflectionAssembly * assembly, char * * minimum, guint32 * minLength, char * * optional, guint32 * optLength, char * * refused, guint32 * refLength)
{
  struct MonoAssembly * D.28644;
  unsigned char D.28645;
  char * D.28648;
  unsigned int D.28649;
  unsigned char D.28650;
  unsigned char D.28653;
  MonoBoolean D.28656;
  MonoBoolean result;
  struct MonoDeclSecurityEntry entry;

  try
    {
      result = 0;
      D.28644 = assembly->assembly;
      D.28645 = mono_declsec_get_assembly_action (D.28644, 8, &entry);
      if (D.28645 != 0) goto <D.28646>; else goto <D.28647>;
      <D.28646>:
      D.28648 = entry.blob;
      *minimum = D.28648;
      D.28649 = entry.size;
      *minLength = D.28649;
      result = 1;
      <D.28647>:
      D.28644 = assembly->assembly;
      D.28650 = mono_declsec_get_assembly_action (D.28644, 9, &entry);
      if (D.28650 != 0) goto <D.28651>; else goto <D.28652>;
      <D.28651>:
      D.28648 = entry.blob;
      *optional = D.28648;
      D.28649 = entry.size;
      *optLength = D.28649;
      result = 1;
      <D.28652>:
      D.28644 = assembly->assembly;
      D.28653 = mono_declsec_get_assembly_action (D.28644, 10, &entry);
      if (D.28653 != 0) goto <D.28654>; else goto <D.28655>;
      <D.28654>:
      D.28648 = entry.blob;
      *refused = D.28648;
      D.28649 = entry.size;
      *refLength = D.28649;
      result = 1;
      <D.28655>:
      D.28656 = result;
      return D.28656;
    }
  finally
    {
      entry = {CLOBBER};
    }
}


ves_icall_System_Reflection_Assembly_InternalImageRuntimeVersion (struct MonoReflectionAssembly * assembly)
{
  struct MonoVTable * D.28659;
  struct MonoString * D.28660;
  struct MonoAssembly * D.28661;
  struct MonoImage * D.28662;
  char * D.28663;
  struct MonoDomain * domain;

  D.28659 = MEM[(struct MonoObject *)assembly].vtable;
  domain = D.28659->domain;
  D.28661 = assembly->assembly;
  D.28662 = D.28661->image;
  D.28663 = D.28662->version;
  D.28660 = mono_string_new (domain, D.28663);
  return D.28660;
}


ves_icall_System_Reflection_Assembly_InternalGetType (struct MonoReflectionAssembly * assembly, struct MonoReflectionModule * module, struct MonoString * name, MonoBoolean throwOnError, MonoBoolean ignoreCase)
{
  int D.28665;
  struct MonoException * D.28670;
  struct MonoReflectionType * D.28671;
  const char * D.28672;
  struct MonoClass * D.28677;
  struct MonoException * D.28680;
  struct MonoException * D.28682;
  struct MonoImage * D.28685;
  int D.28688;
  struct MonoAssembly * D.28691;
  unsigned char D.28692;
  struct MonoArray * D.28695;
  unsigned int i.160;
  char * D.28699;
  struct MonoDynamicImage * D.28700;
  struct MonoImage * D.28701;
  unsigned int D.28703;
  struct MonoArray * D.28706;
  char * D.28709;
  struct MonoImage * D.28710;
  unsigned int D.28712;
  struct MonoImage * D.28714;
  struct MonoLoaderError * D.28719;
  struct MonoLoaderError * D.28724;
  struct MonoLoaderError * D.28727;
  struct MonoLoaderError * D.28732;
  struct MonoException * D.28733;
  unsigned char D.28734;
  int D.28737;
  unsigned char D.28740;
  int D.28747;
  struct MonoVTable * D.28752;
  struct MonoDomain * D.28753;
  gchar * str;
  struct MonoType * type;
  struct MonoTypeNameParse info;
  gboolean type_resolve;

  try
    {
      type = 0B;
      type_resolve = 1;
      str = mono_string_to_utf8 (name);
      D.28665 = mono_reflection_parse_type (str, &info);
      if (D.28665 == 0) goto <D.28666>; else goto <D.28667>;
      <D.28666>:
      monoeg_g_free (str);
      mono_reflection_free_type_info (&info);
      if (throwOnError != 0) goto <D.28668>; else goto <D.28669>;
      <D.28668>:
      D.28670 = mono_get_exception_type_load (name, 0B);
      mono_raise_exception (D.28670);
      <D.28669>:
      D.28671 = 0B;
      return D.28671;
      <D.28667>:
      D.28672 = info.assembly.name;
      if (D.28672 != 0B) goto <D.28673>; else goto <D.28674>;
      <D.28673>:
      monoeg_g_free (str);
      mono_reflection_free_type_info (&info);
      if (throwOnError != 0) goto <D.28675>; else goto <D.28676>;
      <D.28675>:
      D.28677 = mono_defaults.generic_ilist_class;
      if (D.28677 != 0B) goto <D.28678>; else goto <D.28679>;
      <D.28678>:
      D.28680 = mono_get_exception_argument (0B, "Type names passed to Assembly.GetType() must not specify an assembly.");
      mono_raise_exception (D.28680);
      goto <D.28681>;
      <D.28679>:
      D.28682 = mono_get_exception_type_load (name, 0B);
      mono_raise_exception (D.28682);
      <D.28681>:
      <D.28676>:
      D.28671 = 0B;
      return D.28671;
      <D.28674>:
      if (module != 0B) goto <D.28683>; else goto <D.28684>;
      <D.28683>:
      D.28685 = module->image;
      if (D.28685 != 0B) goto <D.28686>; else goto <D.28687>;
      <D.28686>:
      D.28685 = module->image;
      D.28688 = (int) ignoreCase;
      type = mono_reflection_get_type (D.28685, &info, D.28688, &type_resolve);
      goto <D.28689>;
      <D.28687>:
      type = 0B;
      <D.28689>:
      goto <D.28690>;
      <D.28684>:
      D.28691 = assembly->assembly;
      D.28692 = D.28691->dynamic;
      if (D.28692 != 0) goto <D.28693>; else goto <D.28694>;
      <D.28693>:
      {
        struct MonoReflectionAssemblyBuilder * abuilder;
        int i;

        abuilder = assembly;
        type = 0B;
        D.28695 = abuilder->modules;
        if (D.28695 != 0B) goto <D.28696>; else goto <D.28697>;
        <D.28696>:
        i = 0;
        goto <D.22099>;
        <D.22098>:
        {
          struct MonoReflectionModuleBuilder * mb;

          D.28695 = abuilder->modules;
          i.160 = (unsigned int) i;
          D.28699 = mono_array_addr_with_size (D.28695, 4, i.160);
          mb = MEM[(struct MonoReflectionModuleBuilder * *)D.28699];
          D.28700 = mb->dynamic_image;
          D.28701 = &D.28700->image;
          D.28688 = (int) ignoreCase;
          type = mono_reflection_get_type (D.28701, &info, D.28688, &type_resolve);
          if (type != 0B) goto <D.22097>; else goto <D.28702>;
          <D.28702>:
        }
        i = i + 1;
        <D.22099>:
        i.160 = (unsigned int) i;
        D.28695 = abuilder->modules;
        D.28703 = mono_array_length (D.28695);
        if (i.160 < D.28703) goto <D.22098>; else goto <D.22097>;
        <D.22097>:
        <D.28697>:
        if (type == 0B) goto <D.28704>; else goto <D.28705>;
        <D.28704>:
        D.28706 = abuilder->loaded_modules;
        if (D.28706 != 0B) goto <D.28707>; else goto <D.28708>;
        <D.28707>:
        i = 0;
        goto <D.22103>;
        <D.22102>:
        {
          struct MonoReflectionModule * mod;

          D.28706 = abuilder->loaded_modules;
          i.160 = (unsigned int) i;
          D.28709 = mono_array_addr_with_size (D.28706, 4, i.160);
          mod = MEM[(struct MonoReflectionModule * *)D.28709];
          D.28710 = mod->image;
          D.28688 = (int) ignoreCase;
          type = mono_reflection_get_type (D.28710, &info, D.28688, &type_resolve);
          if (type != 0B) goto <D.22101>; else goto <D.28711>;
          <D.28711>:
        }
        i = i + 1;
        <D.22103>:
        i.160 = (unsigned int) i;
        D.28706 = abuilder->loaded_modules;
        D.28712 = mono_array_length (D.28706);
        if (i.160 < D.28712) goto <D.22102>; else goto <D.22101>;
        <D.22101>:
        <D.28708>:
        <D.28705>:
      }
      goto <D.28713>;
      <D.28694>:
      D.28691 = assembly->assembly;
      D.28714 = D.28691->image;
      D.28688 = (int) ignoreCase;
      type = mono_reflection_get_type (D.28714, &info, D.28688, &type_resolve);
      <D.28713>:
      <D.28690>:
      monoeg_g_free (str);
      mono_reflection_free_type_info (&info);
      if (type == 0B) goto <D.28715>; else goto <D.28716>;
      <D.28715>:
      {
        struct MonoException * e;

        e = 0B;
        if (throwOnError != 0) goto <D.28717>; else goto <D.28718>;
        <D.28717>:
        e = mono_get_exception_type_load (name, 0B);
        <D.28718>:
        D.28719 = mono_loader_get_last_error ();
        if (D.28719 != 0B) goto <D.28720>; else goto <D.28721>;
        <D.28720>:
        D.28677 = mono_defaults.generic_ilist_class;
        if (D.28677 != 0B) goto <D.28722>; else goto <D.28723>;
        <D.28722>:
        D.28724 = mono_loader_get_last_error ();
        e = mono_loader_error_prepare_exception (D.28724);
        <D.28723>:
        <D.28721>:
        mono_loader_clear_error ();
        if (e != 0B) goto <D.28725>; else goto <D.28726>;
        <D.28725>:
        mono_raise_exception (e);
        <D.28726>:
        D.28671 = 0B;
        return D.28671;
      }
      <D.28716>:
      D.28727 = mono_loader_get_last_error ();
      if (D.28727 != 0B) goto <D.28728>; else goto <D.28729>;
      <D.28728>:
      if (throwOnError != 0) goto <D.28730>; else goto <D.28731>;
      <D.28730>:
      D.28732 = mono_loader_get_last_error ();
      D.28733 = mono_loader_error_prepare_exception (D.28732);
      mono_raise_exception (D.28733);
      <D.28731>:
      mono_loader_clear_error ();
      <D.28729>:
      D.28734 = type->type;
      if (D.28734 == 18) goto <D.28735>; else goto <D.28736>;
      <D.28735>:
      {
        struct MonoClass * klass;

        klass = mono_type_get_class (type);
        D.28737 = mono_is_security_manager_active ();
        if (D.28737 != 0) goto <D.28738>; else goto <D.28739>;
        <D.28738>:
        D.28740 = klass->exception_type;
        if (D.28740 == 0) goto <D.28741>; else goto <D.28742>;
        <D.28741>:
        mono_class_setup_vtable (klass);
        <D.28742>:
        <D.28739>:
        if (throwOnError != 0) goto <D.28745>; else goto <D.28743>;
        <D.28745>:
        D.28740 = klass->exception_type;
        if (D.28740 != 0) goto <D.28746>; else goto <D.28743>;
        <D.28746>:
        {
          struct MonoException * exc;

          exc = mono_class_get_exception_for_failure (klass);
          mono_loader_clear_error ();
          mono_raise_exception (exc);
        }
        goto <D.28744>;
        <D.28743>:
        D.28747 = mono_is_security_manager_active ();
        if (D.28747 != 0) goto <D.28748>; else goto <D.28749>;
        <D.28748>:
        D.28740 = klass->exception_type;
        if (D.28740 == 2) goto <D.28750>; else goto <D.28751>;
        <D.28750>:
        D.28671 = 0B;
        return D.28671;
        <D.28751>:
        <D.28749>:
        <D.28744>:
      }
      <D.28736>:
      D.28752 = MEM[(struct MonoObject *)assembly].vtable;
      D.28753 = D.28752->domain;
      D.28671 = mono_type_get_object (D.28753, type);
      return D.28671;
    }
  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.28758;
  <unnamed type> status.163;
  struct MonoException * D.28767;
  struct MonoDomain * D.28768;
  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.28758 = mono_domain_get ();
      replace_shadow_path (D.28758, dirname, &filename);
      monoeg_g_free (dirname);
      filename.162 = filename;
      image = mono_image_open (filename.162, &status);
      if (image == 0B) goto <D.28759>; else goto <D.28760>;
      <D.28759>:
      {
        struct MonoException * exc;

        filename.162 = filename;
        monoeg_g_free (filename.162);
        status.163 = status;
        if (status.163 == 3) goto <D.28762>; else goto <D.28763>;
        <D.28762>:
        exc = mono_get_exception_bad_image_format2 (0B, fname);
        goto <D.28764>;
        <D.28763>:
        exc = mono_get_exception_file_not_found2 (0B, fname);
        <D.28764>:
        mono_raise_exception (exc);
      }
      <D.28760>:
      res = mono_assembly_fill_assembly_name (image, &name);
      if (res == 0) goto <D.28765>; else goto <D.28766>;
      <D.28765>:
      mono_image_close (image);
      filename.162 = filename;
      monoeg_g_free (filename.162);
      D.28767 = mono_get_exception_argument ("assemblyFile", "The file does not contain a manifest");
      mono_raise_exception (D.28767);
      <D.28766>:
      D.28768 = mono_domain_get ();
      filename.162 = filename;
      fill_reflection_assembly_name (D.28768, 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.28769;
  struct MonoAssembly * D.28770;
  unsigned char D.28771;
  _Bool D.28772;
  long int D.28773;
  long int D.28774;
  int D.28777;
  unsigned int D.28778;
  unsigned int D.28779;
  struct MonoAssembly * D.28782;
  int D.28783;
  unsigned int D.28784;
  unsigned int D.28787;
  struct MonoClass * D.28790;
  unsigned int D.28791;
  int len1.164;
  int len2.165;
  struct MonoArray * exceptions.166;
  struct MonoArray * ex2.167;
  <unnamed-unsigned:24> D.28796;
  int D.28797;
  unsigned int D.28798;
  unsigned int i.168;
  char * D.28800;
  struct MonoType * D.28803;
  unsigned char D.28806;
  unsigned int D.28813;
  unsigned int ex_count.169;
  unsigned int D.28815;
  struct MonoClass * D.28816;
  unsigned int length.170;
  void * D.28818;
  unsigned int j.171;
  char * D.28820;
  _Bool D.28823;
  long int D.28824;
  long int D.28825;
  unsigned int D.28828;
  struct MonoArray * D.28829;
  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.28769 = MEM[(struct MonoObject *)assembly].vtable;
      domain = D.28769->domain;
      D.28770 = assembly->assembly;
      D.28771 = D.28770->dynamic;
      D.28772 = D.28771 != 0;
      D.28773 = (long int) D.28772;
      D.28774 = __builtin_expect (D.28773, 0);
      if (D.28774 != 0) goto <D.28775>; else goto <D.28776>;
      <D.28775>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "icall.c", 5171, "!assembly->assembly->dynamic");
      <D.28776>:
      D.28770 = assembly->assembly;
      image = D.28770->image;
      table = &image->tables[38];
      D.28777 = (int) exportedOnly;
      res = mono_module_get_types (domain, image, &exceptions, D.28777);
      i = 0;
      goto <D.22487>;
      <D.22486>:
      D.28778 = mono_metadata_decode_row_col (table, i, 0);
      D.28779 = D.28778 & 1;
      if (D.28779 == 0) goto <D.28780>; else goto <D.28781>;
      <D.28780>:
      {
        struct MonoImage * loaded_image;

        D.28782 = image->assembly;
        D.28783 = i + 1;
        D.28784 = (unsigned int) D.28783;
        loaded_image = mono_assembly_load_module (D.28782, D.28784);
        if (loaded_image != 0B) goto <D.28785>; else goto <D.28786>;
        <D.28785>:
        {
          struct MonoArray * ex2;
          struct MonoArray * res2;

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

                len1 = mono_array_length (res);
                len2 = mono_array_length (res2);
                D.28790 = mono_defaults.monotype_class;
                D.28791 = len1 + len2;
                res3 = mono_array_new (domain, D.28790, D.28791);
                {
                  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.28790 = mono_defaults.monotype_class;
                D.28791 = len1 + len2;
                ex3 = mono_array_new (domain, D.28790, D.28791);
                {
                  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.28789>:
            }
          finally
            {
              ex2 = {CLOBBER};
            }
        }
        <D.28786>:
      }
      <D.28781>:
      i = i + 1;
      <D.22487>:
      D.28796 = table->rows;
      D.28797 = (int) D.28796;
      if (D.28797 > i) goto <D.22486>; else goto <D.22488>;
      <D.22488>:
      D.28798 = mono_array_length (res);
      len = (int) D.28798;
      ex_count = 0;
      i = 0;
      goto <D.22493>;
      <D.22492>:
      {
        struct MonoReflectionType * t;
        struct MonoClass * klass;

        i.168 = (unsigned int) i;
        D.28800 = mono_array_addr_with_size (res, 4, i.168);
        t = MEM[(void * *)D.28800];
        if (t != 0B) goto <D.28801>; else goto <D.28802>;
        <D.28801>:
        D.28803 = t->type;
        klass = mono_type_get_class (D.28803);
        if (klass != 0B) goto <D.28804>; else goto <D.28805>;
        <D.28804>:
        D.28806 = klass->exception_type;
        if (D.28806 != 0) goto <D.28807>; else goto <D.28808>;
        <D.28807>:
        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.28808>:
        <D.28805>:
        goto <D.28809>;
        <D.28802>:
        ex_count = ex_count + 1;
        <D.28809>:
      }
      i = i + 1;
      <D.22493>:
      if (i < len) goto <D.22492>; else goto <D.22494>;
      <D.22494>:
      if (list != 0B) goto <D.28810>; else goto <D.28812>;
      <D.28812>:
      if (ex_count != 0) goto <D.28810>; else goto <D.28811>;
      <D.28810>:
      {
        struct GList * tmp;
        struct MonoException * exc;
        struct MonoArray * exl;
        int j;
        int length;

        tmp = 0B;
        exc = 0B;
        exl = 0B;
        D.28813 = monoeg_g_list_length (list);
        ex_count.169 = (unsigned int) ex_count;
        D.28815 = D.28813 + ex_count.169;
        length = (int) D.28815;
        mono_loader_clear_error ();
        D.28816 = mono_defaults.exception_class;
        length.170 = (unsigned int) length;
        exl = mono_array_new (domain, D.28816, length.170);
        i = 0;
        tmp = list;
        goto <D.22503>;
        <D.22502>:
        {
          struct MonoException * exc;

          D.28818 = tmp->data;
          exc = mono_class_get_exception_for_failure (D.28818);
          {
            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.22503>:
        if (tmp != 0B) goto <D.22502>; else goto <D.22504>;
        <D.22504>:
        j = 0;
        goto <D.22508>;
        <D.22507>:
        {
          struct MonoException * exc;

          exceptions.166 = exceptions;
          j.171 = (unsigned int) j;
          D.28820 = mono_array_addr_with_size (exceptions.166, 4, j.171);
          exc = MEM[(struct MonoException * *)D.28820];
          if (exc != 0B) goto <D.28821>; else goto <D.28822>;
          <D.28821>:
          D.28823 = i >= length;
          D.28824 = (long int) D.28823;
          D.28825 = __builtin_expect (D.28824, 0);
          if (D.28825 != 0) goto <D.28826>; else goto <D.28827>;
          <D.28826>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "icall.c", 5248, "i < length");
          <D.28827>:
          {
            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.28822>:
        }
        j = j + 1;
        <D.22508>:
        j.171 = (unsigned int) j;
        exceptions.166 = exceptions;
        D.28828 = mono_array_length (exceptions.166);
        if (j.171 < D.28828) goto <D.22507>; else goto <D.22509>;
        <D.22509>:
        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.28811>:
      D.28829 = res;
      return D.28829;
    }
  finally
    {
      exceptions = {CLOBBER};
    }
}


ves_icall_System_Reflection_Assembly_GetReferencedAssemblies (struct MonoReflectionAssembly * assembly)
{
  struct MonoVTable * D.28832;
  struct MonoAssembly * D.28833;
  struct MonoClass * System_Reflection_AssemblyName.172;
  struct MonoImage * D.28837;
  struct MonoClass * System_Reflection_AssemblyName.173;
  struct MonoImage * D.28839;
  <unnamed-unsigned:24> D.28840;
  unsigned int count.174;
  struct MonoMethod * create_culture.175;
  struct MonoMethod * create_culture.176;
  _Bool D.28848;
  long int D.28849;
  long int D.28850;
  struct MonoString * * D.28853;
  unsigned int D.28854;
  const char * D.28855;
  struct MonoString * D.28856;
  unsigned int D.28857;
  int D.28858;
  unsigned int D.28859;
  int D.28860;
  unsigned int D.28861;
  int D.28862;
  unsigned int D.28863;
  int D.28864;
  unsigned int D.28865;
  struct MonoObject * * D.28866;
  int D.28867;
  unsigned int D.28868;
  int D.28869;
  unsigned int D.28870;
  int D.28871;
  unsigned int D.28872;
  int D.28873;
  unsigned int D.28874;
  struct MonoObject * D.28875;
  unsigned int D.28878;
  const char * D.28879;
  struct MonoString * D.28880;
  struct MonoObject * * D.28881;
  struct MonoObject * D.28882;
  unsigned int D.28883;
  const char * pkey_ptr.177;
  const gchar * pkey_ptr.178;
  unsigned int D.28888;
  struct MonoArray * * D.28891;
  struct MonoClass * D.28892;
  struct MonoArray * D.28893;
  struct MonoArray * D.28894;
  char * D.28895;
  struct MonoArray * * D.28897;
  struct MonoArray * D.28898;
  struct MonoArray * D.28899;
  char * D.28900;
  struct MonoArray * D.28902;
  unsigned int i.179;
  struct MonoArray * D.28904;
  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.28832 = MEM[(struct MonoObject *)assembly].vtable;
  domain = D.28832->domain;
  count = 0;
  D.28833 = assembly->assembly;
  image = D.28833->image;
  System_Reflection_AssemblyName.172 = System_Reflection_AssemblyName;
  if (System_Reflection_AssemblyName.172 == 0B) goto <D.28835>; else goto <D.28836>;
  <D.28835>:
  D.28837 = mono_defaults.corlib;
  System_Reflection_AssemblyName.173 = mono_class_from_name (D.28837, "System.Reflection", "AssemblyName");
  System_Reflection_AssemblyName = System_Reflection_AssemblyName.173;
  <D.28836>:
  D.28833 = assembly->assembly;
  D.28839 = D.28833->image;
  t = &D.28839->tables[35];
  D.28840 = t->rows;
  count = (int) D.28840;
  System_Reflection_AssemblyName.172 = System_Reflection_AssemblyName;
  count.174 = (unsigned int) count;
  result = mono_array_new (domain, System_Reflection_AssemblyName.172, count.174);
  if (count > 0) goto <D.28842>; else goto <D.28843>;
  <D.28842>:
  create_culture.175 = create_culture;
  if (create_culture.175 == 0B) goto <D.28845>; else goto <D.28846>;
  <D.28845>:
  {
    struct MonoMethodDesc * desc;

    desc = mono_method_desc_new ("System.Globalization.CultureInfo:CreateCulture(string,bool)", 1);
    D.28837 = mono_defaults.corlib;
    create_culture.176 = mono_method_desc_search_in_image (desc, D.28837);
    create_culture = create_culture.176;
    create_culture.175 = create_culture;
    D.28848 = create_culture.175 == 0B;
    D.28849 = (long int) D.28848;
    D.28850 = __builtin_expect (D.28849, 0);
    if (D.28850 != 0) goto <D.28851>; else goto <D.28852>;
    <D.28851>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "icall.c", 4450, "create_culture");
    <D.28852>:
    mono_method_desc_free (desc);
  }
  <D.28846>:
  <D.28843>:
  i = 0;
  goto <D.22199>;
  <D.22198>:
  {
    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.28853 = &aname->name;
        D.28854 = cols[6];
        D.28855 = mono_metadata_string_heap (image, D.28854);
        D.28856 = mono_string_new (domain, D.28855);
        mono_gc_wbarrier_set_field (aname, D.28853, D.28856);
        D.28857 = cols[0];
        D.28858 = (int) D.28857;
        aname->major = D.28858;
        D.28859 = cols[1];
        D.28860 = (int) D.28859;
        aname->minor = D.28860;
        D.28861 = cols[2];
        D.28862 = (int) D.28861;
        aname->build = D.28862;
        D.28863 = cols[3];
        D.28864 = (int) D.28863;
        aname->revision = D.28864;
        D.28865 = cols[4];
        aname->flags = D.28865;
        aname->versioncompat = 1;
        aname->hashalg = 32772;
        D.28866 = &aname->version;
        D.28867 = aname->major;
        D.28868 = (unsigned int) D.28867;
        D.28869 = aname->minor;
        D.28870 = (unsigned int) D.28869;
        D.28871 = aname->build;
        D.28872 = (unsigned int) D.28871;
        D.28873 = aname->revision;
        D.28874 = (unsigned int) D.28873;
        D.28875 = create_version (domain, D.28868, D.28870, D.28872, D.28874);
        mono_gc_wbarrier_set_field (aname, D.28866, D.28875);
        create_culture.175 = create_culture;
        if (create_culture.175 != 0B) goto <D.28876>; else goto <D.28877>;
        <D.28876>:
        {
          void * args[2];
          MonoBoolean assembly_ref;

          try
            {
              assembly_ref = 1;
              D.28878 = cols[7];
              D.28879 = mono_metadata_string_heap (image, D.28878);
              D.28880 = mono_string_new (domain, D.28879);
              args[0] = D.28880;
              args[1] = &assembly_ref;
              D.28881 = &aname->cultureInfo;
              create_culture.175 = create_culture;
              D.28882 = mono_runtime_invoke (create_culture.175, 0B, &args, 0B);
              mono_gc_wbarrier_set_field (aname, D.28881, D.28882);
            }
          finally
            {
              args = {CLOBBER};
              assembly_ref = {CLOBBER};
            }
        }
        <D.28877>:
        D.28883 = cols[5];
        if (D.28883 != 0) goto <D.28884>; else goto <D.28885>;
        <D.28884>:
        {
          const gchar * pkey_ptr;
          guint32 pkey_len;

          try
            {
              D.28883 = cols[5];
              pkey_ptr.177 = mono_metadata_blob_heap (image, D.28883);
              pkey_ptr = pkey_ptr.177;
              pkey_ptr.178 = pkey_ptr;
              pkey_len = mono_metadata_decode_blob_size (pkey_ptr.178, &pkey_ptr);
              D.28865 = cols[4];
              D.28888 = D.28865 & 1;
              if (D.28888 != 0) goto <D.28889>; else goto <D.28890>;
              <D.28889>:
              D.28891 = &aname->publicKey;
              D.28892 = mono_defaults.byte_class;
              D.28893 = mono_array_new (domain, D.28892, pkey_len);
              mono_gc_wbarrier_set_field (aname, D.28891, D.28893);
              D.28894 = aname->publicKey;
              D.28895 = mono_array_addr_with_size (D.28894, 1, 0);
              pkey_ptr.178 = pkey_ptr;
              memcpy (D.28895, pkey_ptr.178, pkey_len);
              goto <D.28896>;
              <D.28890>:
              D.28897 = &aname->keyToken;
              D.28892 = mono_defaults.byte_class;
              D.28898 = mono_array_new (domain, D.28892, pkey_len);
              mono_gc_wbarrier_set_field (aname, D.28897, D.28898);
              D.28899 = aname->keyToken;
              D.28900 = mono_array_addr_with_size (D.28899, 1, 0);
              pkey_ptr.178 = pkey_ptr;
              memcpy (D.28900, pkey_ptr.178, pkey_len);
              <D.28896>:
            }
          finally
            {
              pkey_ptr = {CLOBBER};
            }
        }
        goto <D.28901>;
        <D.28885>:
        D.28897 = &aname->keyToken;
        D.28892 = mono_defaults.byte_class;
        D.28902 = mono_array_new (domain, D.28892, 0);
        mono_gc_wbarrier_set_field (aname, D.28897, D.28902);
        <D.28901>:
        {
          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.22199>:
  if (i < count) goto <D.22198>; else goto <D.22200>;
  <D.22200>:
  D.28904 = result;
  return D.28904;
}


ves_icall_System_Reflection_Assembly_GetModulesInternal (struct MonoReflectionAssembly * assembly)
{
  struct MonoAssembly * D.28906;
  _Bool D.28907;
  long int D.28908;
  long int D.28909;
  unsigned char D.28912;
  _Bool D.28913;
  long int D.28914;
  long int D.28915;
  <unnamed-unsigned:24> D.28918;
  unsigned int i.180;
  unsigned int D.28920;
  struct MonoImage * * D.28921;
  struct MonoImage * D.28922;
  unsigned int i.181;
  struct MonoImage * D.28926;
  unsigned int file_count.182;
  unsigned int D.28928;
  unsigned int D.28929;
  struct MonoReflectionModule * D.28930;
  unsigned int j.183;
  struct MonoReflectionModule * D.28934;
  unsigned int D.28935;
  struct MonoReflectionModule * D.28938;
  int D.28940;
  struct MonoDomain * D.28943;
  unsigned int D.28944;
  const char * D.28945;
  struct MonoException * D.28946;
  struct MonoReflectionModule * D.28947;
  struct MonoArray * D.28948;
  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.28906 = assembly->assembly;
      image = D.28906->image;
      D.28907 = image == 0B;
      D.28908 = (long int) D.28907;
      D.28909 = __builtin_expect (D.28908, 0);
      if (D.28909 != 0) goto <D.28910>; else goto <D.28911>;
      <D.28910>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "icall.c", 4696, "image != NULL");
      <D.28911>:
      D.28906 = assembly->assembly;
      D.28912 = D.28906->dynamic;
      D.28913 = D.28912 != 0;
      D.28914 = (long int) D.28913;
      D.28915 = __builtin_expect (D.28914, 0);
      if (D.28915 != 0) goto <D.28916>; else goto <D.28917>;
      <D.28916>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "icall.c", 4697, "!assembly->assembly->dynamic");
      <D.28917>:
      table = &image->tables[38];
      D.28918 = table->rows;
      file_count = (int) D.28918;
      modules = image->modules;
      module_count = image->module_count;
      real_module_count = 0;
      i = 0;
      goto <D.22307>;
      <D.22306>:
      i.180 = (unsigned int) i;
      D.28920 = i.180 * 4;
      D.28921 = modules + D.28920;
      D.28922 = *D.28921;
      if (D.28922 != 0B) goto <D.28923>; else goto <D.28924>;
      <D.28923>:
      real_module_count = real_module_count + 1;
      <D.28924>:
      i = i + 1;
      <D.22307>:
      i.181 = (unsigned int) i;
      if (i.181 < module_count) goto <D.22306>; else goto <D.22308>;
      <D.22308>:
      D.28926 = mono_defaults.corlib;
      klass = mono_class_from_name (D.28926, "System.Reflection", "Module");
      file_count.182 = (unsigned int) file_count;
      D.28928 = real_module_count + file_count.182;
      D.28929 = D.28928 + 1;
      res = mono_array_new (domain, klass, D.28929);
      {
        void * * __p;

        __p = mono_array_addr_with_size (res, 4, 0);
        D.28930 = mono_module_get_object (domain, image);
        mono_gc_wbarrier_set_arrayref (res, __p, D.28930);
      }
      j = 1;
      i = 0;
      goto <D.22312>;
      <D.22311>:
      i.180 = (unsigned int) i;
      D.28920 = i.180 * 4;
      D.28921 = modules + D.28920;
      D.28922 = *D.28921;
      if (D.28922 != 0B) goto <D.28931>; else goto <D.28932>;
      <D.28931>:
      {
        void * * __p;

        j.183 = (unsigned int) j;
        __p = mono_array_addr_with_size (res, 4, j.183);
        i.180 = (unsigned int) i;
        D.28920 = i.180 * 4;
        D.28921 = modules + D.28920;
        D.28922 = *D.28921;
        D.28934 = mono_module_get_object (domain, D.28922);
        mono_gc_wbarrier_set_arrayref (res, __p, D.28934);
      }
      j = j + 1;
      <D.28932>:
      i = i + 1;
      <D.22312>:
      i.181 = (unsigned int) i;
      if (i.181 < module_count) goto <D.22311>; else goto <D.22313>;
      <D.22313>:
      i = 0;
      goto <D.22319>;
      <D.22318>:
      mono_metadata_decode_row (table, i, &cols, 3);
      D.28935 = cols[0];
      if (D.28935 != 0) goto <D.28936>; else goto <D.28937>;
      <D.28936>:
      {
        void * * __p;

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

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

          D.28943 = mono_domain_get ();
          D.28944 = cols[1];
          D.28945 = mono_metadata_string_heap (image, D.28944);
          fname = mono_string_new (D.28943, D.28945);
          D.28946 = mono_get_exception_file_not_found2 (0B, fname);
          mono_raise_exception (D.28946);
        }
        <D.28942>:
        {
          void * * __p;

          j.183 = (unsigned int) j;
          __p = mono_array_addr_with_size (res, 4, j.183);
          D.28947 = mono_module_get_object (domain, m);
          mono_gc_wbarrier_set_arrayref (res, __p, D.28947);
        }
      }
      <D.28939>:
      i = i + 1;
      j = j + 1;
      <D.22319>:
      if (i < file_count) goto <D.22318>; else goto <D.22320>;
      <D.22320>:
      D.28948 = res;
      return D.28948;
    }
  finally
    {
      cols = {CLOBBER};
    }
}


ves_icall_System_Reflection_Assembly_GetManifestResourceNames (struct MonoReflectionAssembly * assembly)
{
  struct MonoAssembly * D.28951;
  struct MonoImage * D.28952;
  struct MonoVTable * D.28953;
  struct MonoDomain * D.28954;
  struct MonoClass * D.28955;
  <unnamed-unsigned:24> D.28956;
  unsigned int D.28957;
  unsigned int D.28958;
  unsigned int i.184;
  struct MonoString * D.28960;
  int D.28961;
  struct MonoArray * D.28962;
  struct MonoTableInfo * table;
  struct MonoArray * result;
  int i;
  const char * val;

  D.28951 = assembly->assembly;
  D.28952 = D.28951->image;
  table = &D.28952->tables[40];
  D.28953 = MEM[(struct MonoObject *)assembly].vtable;
  D.28954 = D.28953->domain;
  D.28955 = mono_defaults.string_class;
  D.28956 = table->rows;
  D.28957 = (unsigned int) D.28956;
  result = mono_array_new (D.28954, D.28955, D.28957);
  i = 0;
  goto <D.22165>;
  <D.22164>:
  D.28951 = assembly->assembly;
  D.28952 = D.28951->image;
  D.28958 = mono_metadata_decode_row_col (table, i, 2);
  val = mono_metadata_string_heap (D.28952, D.28958);
  {
    void * * __p;

    i.184 = (unsigned int) i;
    __p = mono_array_addr_with_size (result, 4, i.184);
    D.28953 = MEM[(struct MonoObject *)assembly].vtable;
    D.28954 = D.28953->domain;
    D.28960 = mono_string_new (D.28954, val);
    mono_gc_wbarrier_set_arrayref (result, __p, D.28960);
  }
  i = i + 1;
  <D.22165>:
  D.28956 = table->rows;
  D.28961 = (int) D.28956;
  if (D.28961 > i) goto <D.22164>; else goto <D.22166>;
  <D.22166>:
  D.28962 = result;
  return D.28962;
}


ves_icall_System_Reflection_Assembly_GetManifestResourceInternal (struct MonoReflectionAssembly * assembly, struct MonoString * name, gint32 * size, struct MonoReflectionModule * * ref_module)
{
  struct MonoAssembly * D.28964;
  struct MonoImage * D.28965;
  int i.185;
  unsigned int D.28967;
  int D.22227;
  <unnamed-unsigned:24> D.28969;
  unsigned int D.28970;
  void * D.28973;
  unsigned int D.28976;
  _Bool D.28977;
  long int D.28978;
  long int D.28979;
  int file_idx.186;
  struct MonoDomain * D.28986;
  struct MonoReflectionModule * D.28987;
  unsigned int D.28988;
  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.28964 = assembly->assembly;
      D.28965 = D.28964->image;
      table = &D.28965->tables[40];
      i = 0;
      goto <D.22230>;
      <D.22229>:
      i.185 = (int) i;
      mono_metadata_decode_row (table, i.185, &cols, 4);
      D.28964 = assembly->assembly;
      D.28965 = D.28964->image;
      D.28967 = cols[2];
      val = mono_metadata_string_heap (D.28965, D.28967);
      {
        size_t __s1_len;
        size_t __s2_len;

        D.22227 = __builtin_strcmp (val, n);
      }
      if (D.22227 == 0) goto <D.22228>; else goto <D.28968>;
      <D.28968>:
      i = i + 1;
      <D.22230>:
      D.28969 = table->rows;
      D.28970 = (unsigned int) D.28969;
      if (D.28970 > i) goto <D.22229>; else goto <D.22228>;
      <D.22228>:
      monoeg_g_free (n);
      D.28969 = table->rows;
      D.28970 = (unsigned int) D.28969;
      if (D.28970 == i) goto <D.28971>; else goto <D.28972>;
      <D.28971>:
      D.28973 = 0B;
      return D.28973;
      <D.28972>:
      impl = cols[3];
      if (impl != 0) goto <D.28974>; else goto <D.28975>;
      <D.28974>:
      D.28976 = impl & 3;
      D.28977 = D.28976 != 0;
      D.28978 = (long int) D.28977;
      D.28979 = __builtin_expect (D.28978, 0);
      if (D.28979 != 0) goto <D.28980>; else goto <D.28981>;
      <D.28980>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "icall.c", 4553, "(impl & MONO_IMPLEMENTATION_MASK) == MONO_IMPLEMENTATION_FILE");
      <D.28981>:
      file_idx = impl >> 2;
      D.28964 = assembly->assembly;
      D.28965 = D.28964->image;
      file_idx.186 = (int) file_idx;
      module = mono_image_load_file_for_image (D.28965, file_idx.186);
      if (module == 0B) goto <D.28983>; else goto <D.28984>;
      <D.28983>:
      D.28973 = 0B;
      return D.28973;
      <D.28984>:
      goto <D.28985>;
      <D.28975>:
      D.28964 = assembly->assembly;
      module = D.28964->image;
      <D.28985>:
      D.28986 = mono_domain_get ();
      D.28987 = mono_module_get_object (D.28986, module);
      mono_gc_wbarrier_generic_store (ref_module, D.28987);
      D.28988 = cols[0];
      D.28973 = mono_image_get_resource (module, D.28988, size);
      return D.28973;
    }
  finally
    {
      cols = {CLOBBER};
    }
}


ves_icall_System_Reflection_Assembly_GetManifestResourceInfoInternal (struct MonoReflectionAssembly * assembly, struct MonoString * name, struct MonoManifestResourceInfo * info)
{
  struct MonoAssembly * D.28991;
  struct MonoImage * D.28992;
  unsigned int D.28993;
  int D.22250;
  <unnamed-unsigned:24> D.28995;
  int D.28996;
  gboolean D.28999;
  unsigned int D.29000;
  unsigned int D.29004;
  unsigned int D.29005;
  int D.29006;
  unsigned int D.29007;
  struct MonoString * * D.29008;
  struct MonoVTable * D.29009;
  struct MonoDomain * D.29010;
  struct MonoString * D.29011;
  unsigned int D.29012;
  struct MonoAssembly * * D.29016;
  sizetype i.187;
  sizetype D.29018;
  sizetype D.29019;
  struct MonoAssembly * * D.29020;
  struct MonoAssembly * D.29021;
  char * D.29024;
  struct MonoReflectionAssembly * * D.29025;
  struct MonoDomain * D.29026;
  struct MonoReflectionAssembly * D.29027;
  struct MonoReflectionAssembly * D.29028;
  unsigned int D.29029;
  unsigned int D.29030;
  struct MonoTableInfo * table;
  int i;
  guint32 cols[4];
  guint32 file_cols[3];
  const char * val;
  char * n;

  try
    {
      D.28991 = assembly->assembly;
      D.28992 = D.28991->image;
      table = &D.28992->tables[40];
      n = mono_string_to_utf8 (name);
      i = 0;
      goto <D.22253>;
      <D.22252>:
      mono_metadata_decode_row (table, i, &cols, 4);
      D.28991 = assembly->assembly;
      D.28992 = D.28991->image;
      D.28993 = cols[2];
      val = mono_metadata_string_heap (D.28992, D.28993);
      {
        size_t __s1_len;
        size_t __s2_len;

        D.22250 = __builtin_strcmp (val, n);
      }
      if (D.22250 == 0) goto <D.22251>; else goto <D.28994>;
      <D.28994>:
      i = i + 1;
      <D.22253>:
      D.28995 = table->rows;
      D.28996 = (int) D.28995;
      if (D.28996 > i) goto <D.22252>; else goto <D.22251>;
      <D.22251>:
      monoeg_g_free (n);
      D.28995 = table->rows;
      D.28996 = (int) D.28995;
      if (D.28996 == i) goto <D.28997>; else goto <D.28998>;
      <D.28997>:
      D.28999 = 0;
      return D.28999;
      <D.28998>:
      D.29000 = cols[3];
      if (D.29000 == 0) goto <D.29001>; else goto <D.29002>;
      <D.29001>:
      info->location = 5;
      goto <D.29003>;
      <D.29002>:
      D.29000 = cols[3];
      D.29004 = D.29000 & 3;
      switch (D.29004) <default: <D.29031>, case 0: <D.22254>, case 1: <D.22256>, case 2: <D.22259>>
      <D.22254>:
      D.29000 = cols[3];
      D.29005 = D.29000 >> 2;
      i = (int) D.29005;
      D.28991 = assembly->assembly;
      D.28992 = D.28991->image;
      table = &D.28992->tables[38];
      D.29006 = i + -1;
      mono_metadata_decode_row (table, D.29006, &file_cols, 3);
      D.28991 = assembly->assembly;
      D.28992 = D.28991->image;
      D.29007 = file_cols[1];
      val = mono_metadata_string_heap (D.28992, D.29007);
      D.29008 = &info->filename;
      D.29009 = MEM[(struct MonoObject *)assembly].vtable;
      D.29010 = D.29009->domain;
      D.29011 = mono_string_new (D.29010, val);
      mono_gc_wbarrier_set_field (info, D.29008, D.29011);
      D.29012 = file_cols[0];
      if (D.29012 != 0) goto <D.29013>; else goto <D.29014>;
      <D.29013>:
      info->location = 0;
      goto <D.29015>;
      <D.29014>:
      info->location = 1;
      <D.29015>:
      goto <D.22255>;
      <D.22256>:
      D.29000 = cols[3];
      D.29005 = D.29000 >> 2;
      i = (int) D.29005;
      D.28991 = assembly->assembly;
      D.28992 = D.28991->image;
      D.29006 = i + -1;
      mono_assembly_load_reference (D.28992, D.29006);
      D.28991 = assembly->assembly;
      D.28992 = D.28991->image;
      D.29016 = D.28992->references;
      i.187 = (sizetype) i;
      D.29018 = i.187 + 1073741823;
      D.29019 = D.29018 * 4;
      D.29020 = D.29016 + D.29019;
      D.29021 = *D.29020;
      if (D.29021 == 4294967295B) goto <D.29022>; else goto <D.29023>;
      <D.29022>:
      {
        char * msg;
        struct MonoException * ex;

        D.29006 = i + -1;
        D.28991 = assembly->assembly;
        D.28992 = D.28991->image;
        D.29024 = D.28992->name;
        msg = monoeg_g_strdup_printf ("Assembly %d referenced from assembly %s not found ", D.29006, D.29024);
        ex = mono_get_exception_file_not_found2 (msg, 0B);
        monoeg_g_free (msg);
        mono_raise_exception (ex);
      }
      <D.29023>:
      D.29025 = &info->assembly;
      D.29026 = mono_domain_get ();
      D.28991 = assembly->assembly;
      D.28992 = D.28991->image;
      D.29016 = D.28992->references;
      i.187 = (sizetype) i;
      D.29018 = i.187 + 1073741823;
      D.29019 = D.29018 * 4;
      D.29020 = D.29016 + D.29019;
      D.29021 = *D.29020;
      D.29027 = mono_assembly_get_object (D.29026, D.29021);
      mono_gc_wbarrier_set_field (info, D.29025, D.29027);
      D.29028 = info->assembly;
      ves_icall_System_Reflection_Assembly_GetManifestResourceInfoInternal (D.29028, name, info);
      D.29029 = info->location;
      D.29030 = D.29029 | 2;
      info->location = D.29030;
      goto <D.22255>;
      <D.22259>:
      monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "icall.c", 4625);
      <D.29031>:
      <D.22255>:
      <D.29003>:
      D.28999 = 1;
      return D.28999;
    }
  finally
    {
      cols = {CLOBBER};
      file_cols = {CLOBBER};
    }
}


ves_icall_System_Reflection_Assembly_GetManifestModuleInternal (struct MonoReflectionAssembly * assembly)
{
  struct MonoReflectionModule * D.29034;
  struct MonoVTable * D.29035;
  struct MonoDomain * D.29036;
  struct MonoAssembly * D.29037;
  struct MonoImage * D.29038;

  D.29035 = MEM[(struct MonoObject *)assembly].vtable;
  D.29036 = D.29035->domain;
  D.29037 = assembly->assembly;
  D.29038 = D.29037->image;
  D.29034 = mono_module_get_object (D.29036, D.29038);
  return D.29034;
}


ves_icall_System_Reflection_Assembly_GetFilesInternal (struct MonoReflectionAssembly * assembly, struct MonoString * name, MonoBoolean resource_modules)
{
  struct MonoAssembly * D.29040;
  struct MonoImage * D.29041;
  unsigned int D.29044;
  int D.22279;
  char * D.29047;
  struct MonoVTable * D.29048;
  struct MonoDomain * D.29049;
  struct MonoObject * D.29050;
  <unnamed-unsigned:24> D.29051;
  int D.29052;
  unsigned int D.29056;
  unsigned int D.29057;
  struct MonoClass * D.29058;
  unsigned int count.188;
  unsigned int D.29063;
  unsigned int D.29064;
  unsigned int D.29065;
  struct MonoString * D.29066;
  struct MonoTableInfo * table;
  struct MonoArray * result;
  int i;
  int count;
  const char * val;
  char * n;

  D.29040 = assembly->assembly;
  D.29041 = D.29040->image;
  table = &D.29041->tables[38];
  result = 0B;
  if (name != 0B) goto <D.29042>; else goto <D.29043>;
  <D.29042>:
  n = mono_string_to_utf8 (name);
  i = 0;
  goto <D.22282>;
  <D.22281>:
  D.29040 = assembly->assembly;
  D.29041 = D.29040->image;
  D.29044 = mono_metadata_decode_row_col (table, i, 1);
  val = mono_metadata_string_heap (D.29041, D.29044);
  {
    size_t __s1_len;
    size_t __s2_len;

    D.22279 = __builtin_strcmp (val, n);
  }
  if (D.22279 == 0) goto <D.29045>; else goto <D.29046>;
  <D.29045>:
  {
    struct MonoString * fn;

    monoeg_g_free (n);
    D.29040 = assembly->assembly;
    D.29047 = D.29040->basedir;
    n = g_concat_dir_and_file (D.29047, val);
    D.29048 = MEM[(struct MonoObject *)assembly].vtable;
    D.29049 = D.29048->domain;
    fn = mono_string_new (D.29049, n);
    monoeg_g_free (n);
    D.29050 = fn;
    return D.29050;
  }
  <D.29046>:
  i = i + 1;
  <D.22282>:
  D.29051 = table->rows;
  D.29052 = (int) D.29051;
  if (D.29052 > i) goto <D.22281>; else goto <D.22283>;
  <D.22283>:
  monoeg_g_free (n);
  D.29050 = 0B;
  return D.29050;
  <D.29043>:
  count = 0;
  i = 0;
  goto <D.22285>;
  <D.22284>:
  if (resource_modules != 0) goto <D.29053>; else goto <D.29055>;
  <D.29055>:
  D.29056 = mono_metadata_decode_row_col (table, i, 0);
  D.29057 = D.29056 & 1;
  if (D.29057 == 0) goto <D.29053>; else goto <D.29054>;
  <D.29053>:
  count = count + 1;
  <D.29054>:
  i = i + 1;
  <D.22285>:
  D.29051 = table->rows;
  D.29052 = (int) D.29051;
  if (D.29052 > i) goto <D.22284>; else goto <D.22286>;
  <D.22286>:
  D.29048 = MEM[(struct MonoObject *)assembly].vtable;
  D.29049 = D.29048->domain;
  D.29058 = mono_defaults.string_class;
  count.188 = (unsigned int) count;
  result = mono_array_new (D.29049, D.29058, count.188);
  count = 0;
  i = 0;
  goto <D.22289>;
  <D.22288>:
  if (resource_modules != 0) goto <D.29060>; else goto <D.29062>;
  <D.29062>:
  D.29063 = mono_metadata_decode_row_col (table, i, 0);
  D.29064 = D.29063 & 1;
  if (D.29064 == 0) goto <D.29060>; else goto <D.29061>;
  <D.29060>:
  D.29040 = assembly->assembly;
  D.29041 = D.29040->image;
  D.29065 = mono_metadata_decode_row_col (table, i, 1);
  val = mono_metadata_string_heap (D.29041, D.29065);
  D.29040 = assembly->assembly;
  D.29047 = D.29040->basedir;
  n = g_concat_dir_and_file (D.29047, val);
  {
    void * * __p;

    count.188 = (unsigned int) count;
    __p = mono_array_addr_with_size (result, 4, count.188);
    D.29048 = MEM[(struct MonoObject *)assembly].vtable;
    D.29049 = D.29048->domain;
    D.29066 = mono_string_new (D.29049, n);
    mono_gc_wbarrier_set_arrayref (result, __p, D.29066);
  }
  monoeg_g_free (n);
  count = count + 1;
  <D.29061>:
  i = i + 1;
  <D.22289>:
  D.29051 = table->rows;
  D.29052 = (int) D.29051;
  if (D.29052 > i) goto <D.22288>; else goto <D.22290>;
  <D.22290>:
  D.29050 = result;
  return D.29050;
}


g_concat_dir_and_file (const char * dir, const char * file)
{
  char * D.29070;
  unsigned int D.29073;
  sizetype D.29074;
  const char * D.29075;
  char D.29076;

  if (dir == 0B) goto <D.29068>; else goto <D.29069>;
  <D.29068>:
  monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "icall.c", 4511, "dir != NULL");
  D.29070 = 0B;
  return D.29070;
  <D.29069>:
  if (file == 0B) goto <D.29071>; else goto <D.29072>;
  <D.29071>:
  monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "icall.c", 4512, "file != NULL");
  D.29070 = 0B;
  return D.29070;
  <D.29072>:
  D.29073 = strlen (dir);
  D.29074 = D.29073 + 4294967295;
  D.29075 = dir + D.29074;
  D.29076 = *D.29075;
  if (D.29076 != 47) goto <D.29077>; else goto <D.29078>;
  <D.29077>:
  D.29070 = monoeg_g_strconcat (dir, "/", file, 0B);
  return D.29070;
  <D.29078>:
  D.29070 = monoeg_g_strconcat (dir, file, 0B);
  return D.29070;
}


ves_icall_System_Reflection_Assembly_GetExecutingAssembly ()
{
  struct MonoMethod * dest.189;
  _Bool D.29081;
  long int D.29082;
  long int D.29083;
  struct MonoReflectionAssembly * D.29086;
  struct MonoDomain * D.29087;
  struct MonoClass * D.29088;
  struct MonoImage * D.29089;
  struct MonoAssembly * D.29090;
  struct MonoMethod * dest;

  try
    {
      dest = 0B;
      mono_stack_walk_no_il (get_executing, &dest);
      dest.189 = dest;
      D.29081 = dest.189 == 0B;
      D.29082 = (long int) D.29081;
      D.29083 = __builtin_expect (D.29082, 0);
      if (D.29083 != 0) goto <D.29084>; else goto <D.29085>;
      <D.29084>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "icall.c", 4821, "dest");
      <D.29085>:
      D.29087 = mono_domain_get ();
      dest.189 = dest;
      D.29088 = dest.189->klass;
      D.29089 = D.29088->image;
      D.29090 = D.29089->assembly;
      D.29086 = mono_assembly_get_object (D.29087, D.29090);
      return D.29086;
    }
  finally
    {
      dest = {CLOBBER};
    }
}


get_executing (struct MonoMethod * m, gint32 no, gint32 ilo, gboolean managed, void * data)
{
  gboolean D.29095;
  struct MonoMethod * D.29096;
  int D.20820;
  int iftmp.190;
  int D.20819;
  struct MonoClass * D.29102;
  const char[18] * D.29103;
  unsigned char D.29104;
  int D.29105;
  unsigned char D.29106;
  int D.29107;
  const unsigned char * D.29112;
  unsigned char D.29113;
  int D.29114;
  const unsigned char * D.29115;
  unsigned char D.29116;
  int D.29117;
  const unsigned char * D.29122;
  unsigned char D.29123;
  int D.29124;
  const unsigned char * D.29125;
  unsigned char D.29126;
  int D.29127;
  const unsigned char * D.29132;
  unsigned char D.29133;
  int D.29134;
  const unsigned char * D.29135;
  unsigned char D.29136;
  int D.29137;
  const char * D.29139;
  struct MonoMethod * * dest;

  dest = data;
  if (managed == 0) goto <D.29093>; else goto <D.29094>;
  <D.29093>:
  D.29095 = 0;
  return D.29095;
  <D.29094>:
  D.29096 = *dest;
  if (D.29096 == 0B) goto <D.29097>; else goto <D.29098>;
  <D.29097>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      D.29102 = m->klass;
      __s2 = D.29102->name_space;
      D.29103 = "System.Reflection";
      D.29104 = MEM[(const unsigned char *)D.29103];
      D.29105 = (int) D.29104;
      D.29106 = *__s2;
      D.29107 = (int) D.29106;
      __result = D.29105 - D.29107;
      {
        if (__s2_len != 0) goto <D.29108>; else goto <D.29109>;
        <D.29108>:
        if (__result == 0) goto <D.29110>; else goto <D.29111>;
        <D.29110>:
        D.29112 = &MEM[(void *)"System.Reflection" + 1B];
        D.29113 = *D.29112;
        D.29114 = (int) D.29113;
        D.29115 = __s2 + 1;
        D.29116 = *D.29115;
        D.29117 = (int) D.29116;
        __result = D.29114 - D.29117;
        if (__s2_len > 1) goto <D.29118>; else goto <D.29119>;
        <D.29118>:
        if (__result == 0) goto <D.29120>; else goto <D.29121>;
        <D.29120>:
        D.29122 = &MEM[(void *)"System.Reflection" + 2B];
        D.29123 = *D.29122;
        D.29124 = (int) D.29123;
        D.29125 = __s2 + 2;
        D.29126 = *D.29125;
        D.29127 = (int) D.29126;
        __result = D.29124 - D.29127;
        if (__s2_len > 2) goto <D.29128>; else goto <D.29129>;
        <D.29128>:
        if (__result == 0) goto <D.29130>; else goto <D.29131>;
        <D.29130>:
        D.29132 = &MEM[(void *)"System.Reflection" + 3B];
        D.29133 = *D.29132;
        D.29134 = (int) D.29133;
        D.29135 = __s2 + 3;
        D.29136 = *D.29135;
        D.29137 = (int) D.29136;
        __result = D.29134 - D.29137;
        <D.29131>:
        <D.29129>:
        <D.29121>:
        <D.29119>:
        <D.29111>:
        <D.29109>:
      }
      D.20819 = __result;
    }
    iftmp.190 = -D.20819;
    goto <D.29138>;
    <D.29101>:
    D.29102 = m->klass;
    D.29139 = D.29102->name_space;
    iftmp.190 = __builtin_strcmp (D.29139, "System.Reflection");
    <D.29138>:
    D.20820 = iftmp.190;
  }
  if (D.20820 == 0) goto <D.29140>; else goto <D.29141>;
  <D.29140>:
  D.29095 = 0;
  return D.29095;
  <D.29141>:
  *dest = m;
  D.29095 = 1;
  return D.29095;
  <D.29098>:
  D.29095 = 0;
  return D.29095;
}


ves_icall_System_Reflection_Assembly_GetEntryAssembly ()
{
  struct MonoAssembly * D.29143;
  struct MonoReflectionAssembly * D.29146;
  struct MonoDomain * domain;

  domain = mono_domain_get ();
  D.29143 = domain->entry_assembly;
  if (D.29143 == 0B) goto <D.29144>; else goto <D.29145>;
  <D.29144>:
  D.29146 = 0B;
  return D.29146;
  <D.29145>:
  D.29143 = domain->entry_assembly;
  D.29146 = mono_assembly_get_object (domain, D.29143);
  return D.29146;
}


ves_icall_System_Reflection_Assembly_GetCallingAssembly ()
{
  struct MonoMethod * dest.191;
  struct MonoReflectionAssembly * D.29151;
  struct MonoDomain * D.29152;
  struct MonoClass * D.29153;
  struct MonoImage * D.29154;
  struct MonoAssembly * D.29155;
  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.29149>; else goto <D.29150>;
      <D.29149>:
      dest = m;
      <D.29150>:
      D.29152 = mono_domain_get ();
      dest.191 = dest;
      D.29153 = dest.191->klass;
      D.29154 = D.29153->image;
      D.29155 = D.29154->assembly;
      D.29151 = mono_assembly_get_object (D.29152, D.29155);
      return D.29151;
    }
  finally
    {
      dest = {CLOBBER};
    }
}


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

  dest = data;
  if (managed == 0) goto <D.29158>; else goto <D.29159>;
  <D.29158>:
  D.29160 = 0;
  return D.29160;
  <D.29159>:
  D.29161 = *dest;
  if (D.29161 == m) goto <D.29162>; else goto <D.29163>;
  <D.29162>:
  *dest = 0B;
  D.29160 = 0;
  return D.29160;
  <D.29163>:
  D.29161 = *dest;
  if (D.29161 == 0B) goto <D.29164>; else goto <D.29165>;
  <D.29164>:
  *dest = m;
  D.29160 = 1;
  return D.29160;
  <D.29165>:
  D.29160 = 0;
  return D.29160;
}


ves_icall_System_Reflection_Assembly_FillName (struct MonoReflectionAssembly * assembly, struct MonoReflectionAssemblyName * aname)
{
  struct MonoImage * D.29167;
  char * D.29168;
  int D.29169;
  struct MonoVTable * D.29172;
  struct MonoDomain * D.29173;
  struct MonoAssemblyName * D.29174;
  char * D.29175;
  gchar * absolute;
  struct MonoAssembly * mass;

  mass = assembly->assembly;
  D.29167 = mass->image;
  D.29168 = D.29167->name;
  D.29169 = monoeg_g_path_is_absolute (D.29168);
  if (D.29169 != 0) goto <D.29170>; else goto <D.29171>;
  <D.29170>:
  D.29172 = MEM[(struct MonoObject *)assembly].vtable;
  D.29173 = D.29172->domain;
  D.29174 = &mass->aname;
  D.29167 = mass->image;
  D.29168 = D.29167->name;
  fill_reflection_assembly_name (D.29173, aname, D.29174, D.29168, 1, 1, 1);
  return;
  <D.29171>:
  D.29175 = mass->basedir;
  D.29167 = mass->image;
  D.29168 = D.29167->name;
  absolute = monoeg_g_build_path ("/", D.29175, D.29168, 0B);
  D.29172 = MEM[(struct MonoObject *)assembly].vtable;
  D.29173 = D.29172->domain;
  D.29174 = &mass->aname;
  fill_reflection_assembly_name (D.29173, aname, D.29174, absolute, 1, 1, 1);
  monoeg_g_free (absolute);
}


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

  D.29177 = this;
  return D.29177;
}


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

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


ves_icall_System_Object_GetType (struct MonoObject * obj)
{
  struct MonoVTable * D.29181;
  struct MonoClass * D.29182;
  struct MonoClass * D.29183;
  struct MonoReflectionType * D.29186;
  struct MonoDomain * D.29187;
  struct MonoRemoteClass * D.29188;
  struct MonoClass * D.29189;
  struct MonoType * D.29190;
  struct MonoType * D.29191;

  D.29181 = obj->vtable;
  D.29182 = D.29181->klass;
  D.29183 = mono_defaults.transparent_proxy_class;
  if (D.29182 == D.29183) goto <D.29184>; else goto <D.29185>;
  <D.29184>:
  D.29181 = obj->vtable;
  D.29187 = D.29181->domain;
  D.29188 = MEM[(struct MonoTransparentProxy *)obj].remote_class;
  D.29189 = D.29188->proxy_class;
  D.29190 = &D.29189->byval_arg;
  D.29186 = mono_type_get_object (D.29187, D.29190);
  return D.29186;
  <D.29185>:
  D.29181 = obj->vtable;
  D.29187 = D.29181->domain;
  D.29181 = obj->vtable;
  D.29182 = D.29181->klass;
  D.29191 = &D.29182->byval_arg;
  D.29186 = mono_type_get_object (D.29187, D.29191);
  return D.29186;
}


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.29193;
  struct MonoClass * D.29194;
  struct MonoType * D.29195;
  struct MonoType * D.29196;
  unsigned char D.29197;
  _Bool D.29198;
  long int D.29199;
  long int D.29200;

  D.29193 = obj->vtable;
  D.29194 = D.29193->klass;
  D.29195 = &D.29194->byval_arg;
  mtype->type = D.29195;
  D.29196 = mtype->type;
  D.29197 = D.29196->type;
  D.29198 = D.29197 == 0;
  D.29199 = (long int) D.29198;
  D.29200 = __builtin_expect (D.29199, 0);
  if (D.29200 != 0) goto <D.29201>; else goto <D.29202>;
  <D.29201>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "icall.c", 1149, "mtype->type->type");
  <D.29202>:
}


vell_icall_MonoType_get_core_clr_security_level (struct MonoReflectionType * this)
{
  struct MonoType * D.29203;
  int D.29204;
  <unnamed type> D.29205;
  struct MonoClass * klass;

  D.29203 = this->type;
  klass = mono_class_from_mono_type (D.29203);
  mono_class_init_or_throw (klass);
  D.29205 = mono_security_core_clr_class_level (klass);
  D.29204 = (int) D.29205;
  return D.29204;
}


ves_icall_get_attributes (struct MonoReflectionType * type)
{
  struct MonoType * D.29207;
  guint32 D.29208;
  struct MonoClass * klass;

  D.29207 = type->type;
  klass = mono_class_from_mono_type (D.29207);
  D.29208 = klass->flags;
  return D.29208;
}


ves_icall_MonoType_get_Namespace (struct MonoReflectionType * type)
{
  struct MonoType * D.29210;
  struct MonoClass * D.29211;
  const char * D.29212;
  char D.29213;
  struct MonoString * D.29216;
  struct MonoDomain * domain;
  struct MonoClass * class;

  domain = mono_domain_get ();
  D.29210 = type->type;
  class = mono_class_from_mono_type (D.29210);
  goto <D.21290>;
  <D.21289>:
  class = class->nested_in;
  <D.21290>:
  D.29211 = class->nested_in;
  if (D.29211 != 0B) goto <D.21289>; else goto <D.21291>;
  <D.21291>:
  D.29212 = class->name_space;
  D.29213 = *D.29212;
  if (D.29213 == 0) goto <D.29214>; else goto <D.29215>;
  <D.29214>:
  D.29216 = 0B;
  return D.29216;
  <D.29215>:
  D.29212 = class->name_space;
  D.29216 = mono_string_new (domain, D.29212);
  return D.29216;
}


ves_icall_MonoType_get_Name (struct MonoReflectionType * type)
{
  struct MonoType * D.29218;
  unsigned int D.29219;
  unsigned int D.29220;
  const char * D.29223;
  struct MonoString * D.29224;
  struct MonoDomain * domain;
  struct MonoClass * class;

  domain = mono_domain_get ();
  D.29218 = type->type;
  class = mono_class_from_mono_type (D.29218);
  D.29218 = type->type;
  D.29219 = BIT_FIELD_REF <*D.29218, 32, 32>;
  D.29220 = D.29219 & 1073741824;
  if (D.29220 != 0) goto <D.29221>; else goto <D.29222>;
  <D.29221>:
  {
    char * n;
    struct MonoString * res;

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


ves_icall_MonoType_get_Module (struct MonoReflectionType * type)
{
  struct MonoType * D.29226;
  struct MonoReflectionModule * D.29227;
  struct MonoVTable * D.29228;
  struct MonoDomain * D.29229;
  struct MonoImage * D.29230;
  struct MonoClass * class;

  D.29226 = type->type;
  class = mono_class_from_mono_type (D.29226);
  D.29228 = MEM[(struct MonoObject *)type].vtable;
  D.29229 = D.29228->domain;
  D.29230 = class->image;
  D.29227 = mono_module_get_object (D.29229, D.29230);
  return D.29227;
}


ves_icall_MonoType_get_IsGenericParameter (struct MonoReflectionType * type)
{
  MonoBoolean D.29232;
  struct MonoType * D.29233;

  D.29233 = type->type;
  D.29232 = is_generic_parameter (D.29233);
  return D.29232;
}


ves_icall_MonoType_get_DeclaringType (struct MonoReflectionType * type)
{
  struct MonoType * D.29235;
  unsigned int D.29236;
  unsigned int D.29237;
  struct MonoReflectionType * D.29240;
  unsigned char D.29241;
  struct MonoGenericParam * D.29244;
  struct MonoGenericContainer * D.29245;
  struct MonoMethod * D.29249;
  struct MonoClass * D.29251;
  struct MonoReflectionType * iftmp.192;
  struct MonoType * D.29255;
  struct MonoDomain * domain;
  struct MonoClass * class;

  domain = mono_domain_get ();
  D.29235 = type->type;
  D.29236 = BIT_FIELD_REF <*D.29235, 32, 32>;
  D.29237 = D.29236 & 1073741824;
  if (D.29237 != 0) goto <D.29238>; else goto <D.29239>;
  <D.29238>:
  D.29240 = 0B;
  return D.29240;
  <D.29239>:
  D.29235 = type->type;
  D.29241 = D.29235->type;
  if (D.29241 == 19) goto <D.29242>; else goto <D.29243>;
  <D.29242>:
  D.29235 = type->type;
  D.29244 = D.29235->data.generic_param;
  D.29245 = D.29244->owner;
  class = D.29245->owner.klass;
  goto <D.29246>;
  <D.29243>:
  D.29235 = type->type;
  D.29241 = D.29235->type;
  if (D.29241 == 30) goto <D.29247>; else goto <D.29248>;
  <D.29247>:
  D.29235 = type->type;
  D.29244 = D.29235->data.generic_param;
  D.29245 = D.29244->owner;
  D.29249 = D.29245->owner.method;
  class = D.29249->klass;
  goto <D.29250>;
  <D.29248>:
  D.29235 = type->type;
  D.29251 = mono_class_from_mono_type (D.29235);
  class = D.29251->nested_in;
  <D.29250>:
  <D.29246>:
  if (class != 0B) goto <D.29253>; else goto <D.29254>;
  <D.29253>:
  D.29255 = &class->byval_arg;
  iftmp.192 = mono_type_get_object (domain, D.29255);
  goto <D.29256>;
  <D.29254>:
  iftmp.192 = 0B;
  <D.29256>:
  D.29240 = iftmp.192;
  return D.29240;
}


ves_icall_MonoType_get_DeclaringMethod (struct MonoReflectionType * ref_type)
{
  unsigned int D.29260;
  unsigned int D.29261;
  unsigned char D.29263;
  struct MonoException * D.29265;
  struct MonoReflectionMethod * D.29268;
  struct MonoGenericParam * D.29269;
  struct MonoGenericContainer * D.29270;
  _Bool D.29271;
  long int D.29272;
  long int D.29273;
  struct MonoVTable * D.29276;
  struct MonoDomain * D.29277;
  struct MonoClass * D.29278;
  struct MonoMethod * method;
  struct MonoType * type;

  type = ref_type->type;
  D.29260 = BIT_FIELD_REF <*type, 32, 32>;
  D.29261 = D.29260 & 1073741824;
  if (D.29261 != 0) goto <D.29258>; else goto <D.29262>;
  <D.29262>:
  D.29263 = type->type;
  if (D.29263 != 30) goto <D.29264>; else goto <D.29259>;
  <D.29264>:
  D.29263 = type->type;
  if (D.29263 != 19) goto <D.29258>; else goto <D.29259>;
  <D.29258>:
  D.29265 = mono_get_exception_invalid_operation ("DeclaringMethod can only be used on generic arguments");
  mono_raise_exception (D.29265);
  <D.29259>:
  D.29263 = type->type;
  if (D.29263 == 19) goto <D.29266>; else goto <D.29267>;
  <D.29266>:
  D.29268 = 0B;
  return D.29268;
  <D.29267>:
  D.29269 = type->data.generic_param;
  D.29270 = D.29269->owner;
  method = D.29270->owner.method;
  D.29271 = method == 0B;
  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", 2570, "method");
  <D.29275>:
  D.29276 = MEM[(struct MonoObject *)ref_type].vtable;
  D.29277 = D.29276->domain;
  D.29278 = method->klass;
  D.29268 = mono_method_get_object (D.29277, method, D.29278);
  return D.29268;
}


ves_icall_get_type_parent (struct MonoReflectionType * type)
{
  struct MonoType * D.29280;
  struct MonoReflectionType * D.29281;
  struct MonoReflectionType * iftmp.193;
  struct MonoClass * D.29283;
  struct MonoVTable * D.29286;
  struct MonoDomain * D.29287;
  struct MonoType * D.29288;
  struct MonoClass * class;

  D.29280 = type->type;
  class = mono_class_from_mono_type (D.29280);
  D.29283 = class->parent;
  if (D.29283 != 0B) goto <D.29284>; else goto <D.29285>;
  <D.29284>:
  D.29286 = MEM[(struct MonoObject *)type].vtable;
  D.29287 = D.29286->domain;
  D.29283 = class->parent;
  D.29288 = &D.29283->byval_arg;
  iftmp.193 = mono_type_get_object (D.29287, D.29288);
  goto <D.29289>;
  <D.29285>:
  iftmp.193 = 0B;
  <D.29289>:
  D.29281 = iftmp.193;
  return D.29281;
}


ves_icall_MonoType_get_Assembly (struct MonoReflectionType * type)
{
  struct MonoType * D.29291;
  struct MonoReflectionAssembly * D.29292;
  struct MonoImage * D.29293;
  struct MonoAssembly * D.29294;
  struct MonoDomain * domain;
  struct MonoClass * class;

  domain = mono_domain_get ();
  D.29291 = type->type;
  class = mono_class_from_mono_type (D.29291);
  D.29293 = class->image;
  D.29294 = D.29293->assembly;
  D.29292 = mono_assembly_get_object (domain, D.29294);
  return D.29292;
}


ves_icall_System_MonoType_getFullName (struct MonoReflectionType * object, gboolean full_name, gboolean assembly_qualified)
{
  struct MonoVTable * D.29296;
  MonoTypeNameFormat iftmp.194;
  struct MonoType * D.29304;
  struct MonoString * D.29307;
  unsigned char D.29312;
  struct MonoDomain * domain;
  MonoTypeNameFormat format;
  struct MonoString * res;
  gchar * name;

  D.29296 = MEM[(struct MonoObject *)object].vtable;
  domain = D.29296->domain;
  if (full_name != 0) goto <D.29297>; else goto <D.29298>;
  <D.29297>:
  if (assembly_qualified != 0) goto <D.29300>; else goto <D.29301>;
  <D.29300>:
  iftmp.194 = 3;
  goto <D.29302>;
  <D.29301>:
  iftmp.194 = 2;
  <D.29302>:
  format = iftmp.194;
  goto <D.29303>;
  <D.29298>:
  format = 1;
  <D.29303>:
  D.29304 = object->type;
  name = mono_type_get_name_full (D.29304, format);
  if (name == 0B) goto <D.29305>; else goto <D.29306>;
  <D.29305>:
  D.29307 = 0B;
  return D.29307;
  <D.29306>:
  if (full_name != 0) goto <D.29310>; else goto <D.29311>;
  <D.29310>:
  D.29304 = object->type;
  D.29312 = D.29304->type;
  if (D.29312 == 19) goto <D.29308>; else goto <D.29313>;
  <D.29313>:
  D.29304 = object->type;
  D.29312 = D.29304->type;
  if (D.29312 == 30) goto <D.29308>; else goto <D.29309>;
  <D.29308>:
  monoeg_g_free (name);
  D.29307 = 0B;
  return D.29307;
  <D.29309>:
  <D.29311>:
  res = mono_string_new (domain, name);
  monoeg_g_free (name);
  D.29307 = res;
  return D.29307;
}


ves_icall_type_isprimitive (struct MonoReflectionType * type)
{
  MonoBoolean D.29315;
  int iftmp.195;
  struct MonoType * D.29320;
  unsigned int D.29321;
  unsigned int D.29322;
  unsigned char D.29324;
  unsigned char D.29325;

  D.29320 = type->type;
  D.29321 = BIT_FIELD_REF <*D.29320, 32, 32>;
  D.29322 = D.29321 & 1073741824;
  if (D.29322 == 0) goto <D.29323>; else goto <D.29317>;
  <D.29323>:
  D.29320 = type->type;
  D.29324 = D.29320->type;
  D.29325 = D.29324 + 254;
  if (D.29325 <= 11) goto <D.29318>; else goto <D.29326>;
  <D.29326>:
  D.29320 = type->type;
  D.29324 = D.29320->type;
  if (D.29324 == 24) goto <D.29318>; else goto <D.29327>;
  <D.29327>:
  D.29320 = type->type;
  D.29324 = D.29320->type;
  if (D.29324 == 25) goto <D.29318>; else goto <D.29317>;
  <D.29318>:
  iftmp.195 = 1;
  goto <D.29319>;
  <D.29317>:
  iftmp.195 = 0;
  <D.29319>:
  D.29315 = (MonoBoolean) iftmp.195;
  return D.29315;
}


ves_icall_type_ispointer (struct MonoReflectionType * type)
{
  MonoBoolean D.29329;
  struct MonoType * D.29330;
  unsigned char D.29331;
  _Bool D.29332;

  D.29330 = type->type;
  D.29331 = D.29330->type;
  D.29332 = D.29331 == 15;
  D.29329 = (MonoBoolean) D.29332;
  return D.29329;
}


ves_icall_type_iscomobject (struct MonoReflectionType * type)
{
  struct MonoType * D.29334;
  MonoBoolean D.29335;
  <unnamed-unsigned:1> D.29336;
  struct MonoClass * klass;

  D.29334 = type->type;
  klass = mono_class_from_mono_type (D.29334);
  mono_class_init_or_throw (klass);
  D.29336 = klass->is_com_object;
  D.29335 = (MonoBoolean) D.29336;
  return D.29335;
}


ves_icall_type_isbyref (struct MonoReflectionType * type)
{
  MonoBoolean D.29338;
  struct MonoType * D.29339;
  <unnamed-unsigned:1> D.29340;

  D.29339 = type->type;
  D.29340 = D.29339->byref;
  D.29338 = (MonoBoolean) D.29340;
  return D.29338;
}


ves_icall_MonoType_GetEvent (struct MonoReflectionType * type, struct MonoString * name, guint32 bflags)
{
  struct MonoType * D.29342;
  unsigned int D.29343;
  unsigned int D.29344;
  struct MonoReflectionEvent * D.29347;
  struct MonoVTable * D.29348;
  int (*<T3926>) (const char *, const char *) iftmp.196;
  unsigned int D.29350;
  unsigned char D.29354;
  struct MonoException * D.29357;
  const char * D.29358;
  int D.29359;
  short unsigned int D.29368;
  int D.29369;
  int D.29370;
  unsigned int D.29373;
  unsigned int D.29377;
  int D.29384;
  unsigned int D.29387;
  unsigned int D.29390;
  unsigned int D.29396;
  unsigned int D.29402;
  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.29342 = type->type;
      D.29343 = BIT_FIELD_REF <*D.29342, 32, 32>;
      D.29344 = D.29343 & 1073741824;
      if (D.29344 != 0) goto <D.29345>; else goto <D.29346>;
      <D.29345>:
      D.29347 = 0B;
      return D.29347;
      <D.29346>:
      D.29342 = type->type;
      startklass = mono_class_from_mono_type (D.29342);
      klass = startklass;
      D.29348 = MEM[(struct MonoObject *)type].vtable;
      domain = D.29348->domain;
      mono_class_init_or_throw (klass);
      D.29350 = bflags & 1;
      if (D.29350 != 0) goto <D.29351>; else goto <D.29352>;
      <D.29351>:
      iftmp.196 = monoeg_ascii_strcasecmp;
      goto <D.29353>;
      <D.29352>:
      iftmp.196 = strcmp;
      <D.29353>:
      compare_func = iftmp.196;
      handle_parent:
      D.29354 = klass->exception_type;
      if (D.29354 != 0) goto <D.29355>; else goto <D.29356>;
      <D.29355>:
      D.29357 = mono_class_get_exception_for_failure (klass);
      mono_raise_exception (D.29357);
      <D.29356>:
      iter = 0B;
      goto <D.22002>;
      <D.22003>:
      D.29358 = event->name;
      D.29359 = compare_func (D.29358, event_name);
      if (D.29359 != 0) goto <D.29360>; else goto <D.29361>;
      <D.29360>:
      // predicted unlikely by continue predictor.
      goto <D.22002>;
      <D.29361>:
      method = event->add;
      if (method == 0B) goto <D.29362>; else goto <D.29363>;
      <D.29362>:
      method = event->remove;
      <D.29363>:
      if (method == 0B) goto <D.29364>; else goto <D.29365>;
      <D.29364>:
      method = event->raise;
      <D.29365>:
      if (method != 0B) goto <D.29366>; else goto <D.29367>;
      <D.29366>:
      D.29368 = method->flags;
      D.29369 = (int) D.29368;
      D.29370 = D.29369 & 7;
      if (D.29370 == 6) goto <D.29371>; else goto <D.29372>;
      <D.29371>:
      D.29373 = bflags & 16;
      if (D.29373 == 0) goto <D.29374>; else goto <D.29375>;
      <D.29374>:
      // predicted unlikely by continue predictor.
      goto <D.22002>;
      <D.29375>:
      goto <D.29376>;
      <D.29372>:
      D.29377 = bflags & 32;
      if (D.29377 == 0) goto <D.29378>; else goto <D.29379>;
      <D.29378>:
      // predicted unlikely by continue predictor.
      goto <D.22002>;
      <D.29379>:
      if (klass != startklass) goto <D.29380>; else goto <D.29381>;
      <D.29380>:
      D.29368 = method->flags;
      D.29369 = (int) D.29368;
      D.29370 = D.29369 & 7;
      if (D.29370 == 1) goto <D.29382>; else goto <D.29383>;
      <D.29382>:
      // predicted unlikely by continue predictor.
      goto <D.22002>;
      <D.29383>:
      <D.29381>:
      <D.29376>:
      D.29368 = method->flags;
      D.29369 = (int) D.29368;
      D.29384 = D.29369 & 16;
      if (D.29384 != 0) goto <D.29385>; else goto <D.29386>;
      <D.29385>:
      D.29387 = bflags & 8;
      if (D.29387 == 0) goto <D.29388>; else goto <D.29389>;
      <D.29388>:
      // predicted unlikely by continue predictor.
      goto <D.22002>;
      <D.29389>:
      D.29390 = bflags & 64;
      if (D.29390 == 0) goto <D.29391>; else goto <D.29392>;
      <D.29391>:
      if (klass != startklass) goto <D.29393>; else goto <D.29394>;
      <D.29393>:
      // predicted unlikely by continue predictor.
      goto <D.22002>;
      <D.29394>:
      <D.29392>:
      goto <D.29395>;
      <D.29386>:
      D.29396 = bflags & 4;
      if (D.29396 == 0) goto <D.29397>; else goto <D.29398>;
      <D.29397>:
      // predicted unlikely by continue predictor.
      goto <D.22002>;
      <D.29398>:
      <D.29395>:
      goto <D.29399>;
      <D.29367>:
      D.29377 = bflags & 32;
      if (D.29377 == 0) goto <D.29400>; else goto <D.29401>;
      <D.29400>:
      // predicted unlikely by continue predictor.
      goto <D.22002>;
      <D.29401>:
      <D.29399>:
      monoeg_g_free (event_name);
      D.29347 = mono_event_get_object (domain, startklass, event);
      return D.29347;
      <D.22002>:
      event = mono_class_get_events (klass, &iter);
      if (event != 0B) goto <D.22003>; else goto <D.22004>;
      <D.22004>:
      D.29402 = bflags & 2;
      if (D.29402 == 0) goto <D.29403>; else goto <D.29404>;
      <D.29403>:
      klass = klass->parent;
      if (klass != 0B) goto handle_parent; else goto <D.29405>;
      <D.29405>:
      <D.29404>:
      monoeg_g_free (event_name);
      D.29347 = 0B;
      return D.29347;
    }
  finally
    {
      iter = {CLOBBER};
    }
}


ves_icall_Type_GetPropertiesByName (struct MonoReflectionType * type, struct MonoString * name, guint32 bflags, MonoBoolean ignore_case, struct MonoReflectionType * reftype)
{
  void * D.29408;
  struct MonoClass * System_Reflection_PropertyInfo.197;
  struct MonoImage * D.29412;
  struct MonoClass * System_Reflection_PropertyInfo.198;
  struct MonoVTable * D.29414;
  struct MonoType * D.29415;
  unsigned int D.29416;
  unsigned int D.29417;
  struct MonoArray * D.29420;
  struct MonoClass * D.21973;
  struct MonoClass * tmp_klass.199;
  struct MonoClass * tmp_klass.200;
  _Bool D.29425;
  long int D.29426;
  long int D.29427;
  struct MonoVTable * D.29430;
  int (*<T3926>) (const char *, const char *) iftmp.201;
  unsigned char D.29437;
  struct MonoLoaderError * D.29439;
  short unsigned int D.29445;
  struct MonoMethod * D.29451;
  short unsigned int D.29453;
  int D.29454;
  int D.29455;
  struct MonoMethod * D.29456;
  short unsigned int D.29458;
  int D.29459;
  int D.29460;
  unsigned int D.29461;
  unsigned int D.29464;
  _Bool D.29469;
  int D.29470;
  int D.29471;
  int D.29473;
  unsigned int D.29476;
  unsigned int D.29479;
  unsigned int D.29484;
  unsigned int D.29487;
  const char * D.29494;
  int D.29495;
  void * D.29498;
  int D.29501;
  int D.29502;
  unsigned int D.29505;
  unsigned int D.29506;
  int D.29507;
  void * D.29508;
  void * * D.29509;
  unsigned int D.29510;
  int D.29513;
  int D.29514;
  unsigned int D.29515;
  unsigned int D.29516;
  void * * D.29517;
  struct MonoReflectionProperty * D.29518;
  unsigned int D.29519;
  struct MonoClass * D.21981;
  struct MonoClass * tmp_klass.202;
  struct MonoClass * tmp_klass.203;
  _Bool D.29527;
  long int D.29528;
  long int D.29529;
  struct MonoVTable * D.29532;
  unsigned int D.29533;
  unsigned int i.204;
  unsigned int i.205;
  unsigned int D.29536;
  void * * D.29537;
  void * D.29538;
  struct MonoLoaderError * D.29550;
  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.29408 = __builtin_alloca (64);
      tmp_array.data = D.29408;
      System_Reflection_PropertyInfo.197 = System_Reflection_PropertyInfo;
      if (System_Reflection_PropertyInfo.197 == 0B) goto <D.29410>; else goto <D.29411>;
      <D.29410>:
      D.29412 = mono_defaults.corlib;
      System_Reflection_PropertyInfo.198 = mono_class_from_name (D.29412, "System.Reflection", "PropertyInfo");
      System_Reflection_PropertyInfo = System_Reflection_PropertyInfo.198;
      <D.29411>:
      D.29414 = MEM[(struct MonoObject *)type].vtable;
      domain = D.29414->domain;
      D.29415 = type->type;
      D.29416 = BIT_FIELD_REF <*D.29415, 32, 32>;
      D.29417 = D.29416 & 1073741824;
      if (D.29417 != 0) goto <D.29418>; else goto <D.29419>;
      <D.29418>:
      {
        static struct MonoClass * tmp_klass;

        {
          tmp_klass.199 = tmp_klass;
          if (tmp_klass.199 == 0B) goto <D.29422>; else goto <D.29423>;
          <D.29422>:
          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.29425 = tmp_klass.199 == 0B;
          D.29426 = (long int) D.29425;
          D.29427 = __builtin_expect (D.29426, 0);
          if (D.29427 != 0) goto <D.29428>; else goto <D.29429>;
          <D.29428>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "icall.c", 3725, "tmp_klass");
          <D.29429>:
          <D.29423>:
        }
        D.21973 = tmp_klass;
      }
      D.29430 = mono_class_vtable (domain, D.21973);
      D.29420 = mono_array_new_specific (D.29430, 0);
      return D.29420;
      <D.29419>:
      D.29415 = type->type;
      startklass = mono_class_from_mono_type (D.29415);
      klass = startklass;
      if (name != 0B) goto <D.29431>; else goto <D.29432>;
      <D.29431>:
      propname = mono_string_to_utf8 (name);
      if (ignore_case != 0) goto <D.29434>; else goto <D.29435>;
      <D.29434>:
      iftmp.201 = monoeg_ascii_strcasecmp;
      goto <D.29436>;
      <D.29435>:
      iftmp.201 = strcmp;
      <D.29436>:
      compare_func = iftmp.201;
      <D.29432>:
      properties = monoeg_g_hash_table_new (property_hash, property_equal);
      handle_parent:
      mono_class_setup_vtable (klass);
      D.29437 = klass->exception_type;
      if (D.29437 != 0) goto loader_error; else goto <D.29438>;
      <D.29438>:
      D.29439 = mono_loader_get_last_error ();
      if (D.29439 != 0B) goto loader_error; else goto <D.29440>;
      <D.29440>:
      iter = 0B;
      goto <D.21976>;
      <D.21978>:
      match = 0;
      method = prop->get;
      if (method == 0B) goto <D.29441>; else goto <D.29442>;
      <D.29441>:
      method = prop->set;
      <D.29442>:
      if (method != 0B) goto <D.29443>; else goto <D.29444>;
      <D.29443>:
      D.29445 = method->flags;
      flags = (guint32) D.29445;
      goto <D.29446>;
      <D.29444>:
      flags = 0;
      <D.29446>:
      D.29451 = prop->get;
      if (D.29451 != 0B) goto <D.29452>; else goto <D.29447>;
      <D.29452>:
      D.29451 = prop->get;
      D.29453 = D.29451->flags;
      D.29454 = (int) D.29453;
      D.29455 = D.29454 & 7;
      if (D.29455 == 6) goto <D.29448>; else goto <D.29447>;
      <D.29447>:
      D.29456 = prop->set;
      if (D.29456 != 0B) goto <D.29457>; else goto <D.29449>;
      <D.29457>:
      D.29456 = prop->set;
      D.29458 = D.29456->flags;
      D.29459 = (int) D.29458;
      D.29460 = D.29459 & 7;
      if (D.29460 == 6) goto <D.29448>; else goto <D.29449>;
      <D.29448>:
      D.29461 = bflags & 16;
      if (D.29461 != 0) goto <D.29462>; else goto <D.29463>;
      <D.29462>:
      match = match + 1;
      <D.29463>:
      goto <D.29450>;
      <D.29449>:
      D.29464 = bflags & 32;
      if (D.29464 != 0) goto <D.29465>; else goto <D.29466>;
      <D.29465>:
      D.29451 = prop->get;
      D.29469 = startklass == klass;
      D.29470 = (int) D.29469;
      D.29471 = property_accessor_nonpublic (D.29451, D.29470);
      if (D.29471 != 0) goto <D.29467>; else goto <D.29472>;
      <D.29472>:
      D.29456 = prop->set;
      D.29469 = startklass == klass;
      D.29470 = (int) D.29469;
      D.29473 = property_accessor_nonpublic (D.29456, D.29470);
      if (D.29473 != 0) goto <D.29467>; else goto <D.29468>;
      <D.29467>:
      match = match + 1;
      <D.29468>:
      <D.29466>:
      <D.29450>:
      if (match == 0) goto <D.29474>; else goto <D.29475>;
      <D.29474>:
      // predicted unlikely by continue predictor.
      goto <D.21976>;
      <D.29475>:
      match = 0;
      D.29476 = flags & 16;
      if (D.29476 != 0) goto <D.29477>; else goto <D.29478>;
      <D.29477>:
      D.29479 = bflags & 8;
      if (D.29479 != 0) goto <D.29480>; else goto <D.29481>;
      <D.29480>:
      D.29484 = bflags & 64;
      if (D.29484 != 0) goto <D.29482>; else goto <D.29485>;
      <D.29485>:
      if (klass == startklass) goto <D.29482>; else goto <D.29483>;
      <D.29482>:
      match = match + 1;
      <D.29483>:
      <D.29481>:
      goto <D.29486>;
      <D.29478>:
      D.29487 = bflags & 4;
      if (D.29487 != 0) goto <D.29488>; else goto <D.29489>;
      <D.29488>:
      match = match + 1;
      <D.29489>:
      <D.29486>:
      if (match == 0) goto <D.29490>; else goto <D.29491>;
      <D.29490>:
      // predicted unlikely by continue predictor.
      goto <D.21976>;
      <D.29491>:
      match = 0;
      if (name != 0B) goto <D.29492>; else goto <D.29493>;
      <D.29492>:
      D.29494 = prop->name;
      D.29495 = compare_func (propname, D.29494);
      if (D.29495 != 0) goto <D.29496>; else goto <D.29497>;
      <D.29496>:
      // predicted unlikely by continue predictor.
      goto <D.21976>;
      <D.29497>:
      <D.29493>:
      D.29498 = monoeg_g_hash_table_lookup (properties, prop);
      if (D.29498 != 0B) goto <D.29499>; else goto <D.29500>;
      <D.29499>:
      // predicted unlikely by continue predictor.
      goto <D.21976>;
      <D.29500>:
      D.29501 = tmp_array.size;
      D.29502 = tmp_array.capacity;
      if (D.29501 >= D.29502) goto <D.29503>; else goto <D.29504>;
      <D.29503>:
      {
        void * __tmp;

        D.29502 = tmp_array.capacity;
        D.29505 = (unsigned int) D.29502;
        D.29506 = D.29505 * 8;
        D.29502 = tmp_array.capacity;
        D.29507 = D.29502 * 2;
        D.29508 = mono_gc_make_root_descr_all_refs (D.29507);
        __tmp = mono_gc_alloc_fixed (D.29506, D.29508);
        D.29509 = tmp_array.data;
        D.29502 = tmp_array.capacity;
        D.29505 = (unsigned int) D.29502;
        D.29510 = D.29505 * 4;
        mono_gc_memmove_aligned (__tmp, D.29509, D.29510);
        D.29502 = tmp_array.capacity;
        if (D.29502 > 16) goto <D.29511>; else goto <D.29512>;
        <D.29511>:
        D.29509 = tmp_array.data;
        mono_gc_free_fixed (D.29509);
        <D.29512>:
        tmp_array.data = __tmp;
        D.29502 = tmp_array.capacity;
        D.29507 = D.29502 * 2;
        tmp_array.capacity = D.29507;
      }
      <D.29504>:
      D.29509 = tmp_array.data;
      D.29501 = tmp_array.size;
      D.29513 = D.29501;
      D.29514 = D.29513 + 1;
      tmp_array.size = D.29514;
      D.29515 = (unsigned int) D.29513;
      D.29516 = D.29515 * 4;
      D.29517 = D.29509 + D.29516;
      D.29518 = mono_property_get_object (domain, startklass, prop);
      *D.29517 = D.29518;
      monoeg_g_hash_table_insert_replace (properties, prop, prop, 0);
      <D.21976>:
      prop = mono_class_get_properties (klass, &iter);
      if (prop != 0B) goto <D.21978>; else goto <D.21979>;
      <D.21979>:
      D.29519 = bflags & 2;
      if (D.29519 == 0) goto <D.29520>; else goto <D.29521>;
      <D.29520>:
      klass = klass->parent;
      if (klass != 0B) goto handle_parent; else goto <D.29522>;
      <D.29522>:
      <D.29521>:
      monoeg_g_hash_table_destroy (properties);
      monoeg_g_free (propname);
      {
        static struct MonoClass * tmp_klass;

        {
          tmp_klass.202 = tmp_klass;
          if (tmp_klass.202 == 0B) goto <D.29524>; else goto <D.29525>;
          <D.29524>:
          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.29527 = tmp_klass.202 == 0B;
          D.29528 = (long int) D.29527;
          D.29529 = __builtin_expect (D.29528, 0);
          if (D.29529 != 0) goto <D.29530>; else goto <D.29531>;
          <D.29530>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "icall.c", 3793, "tmp_klass");
          <D.29531>:
          <D.29525>:
        }
        D.21981 = tmp_klass;
      }
      D.29532 = mono_class_vtable (domain, D.21981);
      D.29501 = tmp_array.size;
      D.29533 = (unsigned int) D.29501;
      res = mono_array_new_specific (D.29532, D.29533);
      i = 0;
      goto <D.21984>;
      <D.21983>:
      {
        void * * __p;

        i.204 = (unsigned int) i;
        __p = mono_array_addr_with_size (res, 4, i.204);
        D.29509 = tmp_array.data;
        i.205 = (unsigned int) i;
        D.29536 = i.205 * 4;
        D.29537 = D.29509 + D.29536;
        D.29538 = *D.29537;
        mono_gc_wbarrier_set_arrayref (res, __p, D.29538);
      }
      i = i + 1;
      <D.21984>:
      D.29501 = tmp_array.size;
      if (D.29501 > i) goto <D.21983>; else goto <D.21985>;
      <D.21985>:
      D.29502 = tmp_array.capacity;
      if (D.29502 > 16) goto <D.29539>; else goto <D.29540>;
      <D.29539>:
      D.29509 = tmp_array.data;
      mono_gc_free_fixed (D.29509);
      <D.29540>:
      D.29420 = res;
      return D.29420;
      loader_error:
      if (properties != 0B) goto <D.29541>; else goto <D.29542>;
      <D.29541>:
      monoeg_g_hash_table_destroy (properties);
      <D.29542>:
      if (name != 0B) goto <D.29543>; else goto <D.29544>;
      <D.29543>:
      monoeg_g_free (propname);
      <D.29544>:
      D.29502 = tmp_array.capacity;
      if (D.29502 > 16) goto <D.29545>; else goto <D.29546>;
      <D.29545>:
      D.29509 = tmp_array.data;
      mono_gc_free_fixed (D.29509);
      <D.29546>:
      D.29437 = klass->exception_type;
      if (D.29437 != 0) goto <D.29547>; else goto <D.29548>;
      <D.29547>:
      ex = mono_class_get_exception_for_failure (klass);
      goto <D.29549>;
      <D.29548>:
      D.29550 = mono_loader_get_last_error ();
      ex = mono_loader_error_prepare_exception (D.29550);
      mono_loader_clear_error ();
      <D.29549>:
      mono_raise_exception (ex);
      D.29420 = 0B;
      return D.29420;
    }
  finally
    {
      iter = {CLOBBER};
      tmp_array = {CLOBBER};
    }
}


property_equal (struct MonoProperty * prop1, struct MonoProperty * prop2)
{
  const char * D.29553;
  const char * D.29554;
  int D.29555;
  gboolean D.29558;
  struct MonoMethod * D.29559;
  struct MonoMethod * D.29562;
  struct MonoMethodSignature * D.29565;
  struct MonoMethodSignature * D.29566;
  int D.29567;
  struct MonoMethod * D.29570;
  struct MonoMethod * D.29573;
  struct MonoMethodSignature * D.29576;
  struct MonoMethodSignature * D.29577;
  int D.29578;

  D.29553 = prop1->name;
  D.29554 = prop2->name;
  D.29555 = monoeg_g_str_equal (D.29553, D.29554);
  if (D.29555 == 0) goto <D.29556>; else goto <D.29557>;
  <D.29556>:
  D.29558 = 0;
  return D.29558;
  <D.29557>:
  D.29559 = prop1->get;
  if (D.29559 != 0B) goto <D.29560>; else goto <D.29561>;
  <D.29560>:
  D.29562 = prop2->get;
  if (D.29562 != 0B) goto <D.29563>; else goto <D.29564>;
  <D.29563>:
  D.29559 = prop1->get;
  D.29565 = mono_method_signature (D.29559);
  D.29562 = prop2->get;
  D.29566 = mono_method_signature (D.29562);
  D.29567 = mono_metadata_signature_equal (D.29565, D.29566);
  if (D.29567 == 0) goto <D.29568>; else goto <D.29569>;
  <D.29568>:
  D.29558 = 0;
  return D.29558;
  <D.29569>:
  <D.29564>:
  <D.29561>:
  D.29570 = prop1->set;
  if (D.29570 != 0B) goto <D.29571>; else goto <D.29572>;
  <D.29571>:
  D.29573 = prop2->set;
  if (D.29573 != 0B) goto <D.29574>; else goto <D.29575>;
  <D.29574>:
  D.29570 = prop1->set;
  D.29576 = mono_method_signature (D.29570);
  D.29573 = prop2->set;
  D.29577 = mono_method_signature (D.29573);
  D.29578 = mono_metadata_signature_equal (D.29576, D.29577);
  if (D.29578 == 0) goto <D.29579>; else goto <D.29580>;
  <D.29579>:
  D.29558 = 0;
  return D.29558;
  <D.29580>:
  <D.29575>:
  <D.29572>:
  D.29558 = 1;
  return D.29558;
}


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

  prop = data;
  D.29583 = prop->name;
  D.29582 = monoeg_g_str_hash (D.29583);
  return D.29582;
}


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

  if (accessor == 0B) goto <D.29585>; else goto <D.29586>;
  <D.29585>:
  D.29587 = 0;
  return D.29587;
  <D.29586>:
  D.29587 = method_nonpublic (accessor, start_klass);
  return D.29587;
}


ves_icall_Type_GetNestedTypes (struct MonoReflectionType * type, guint32 bflags)
{
  struct MonoVTable * D.29589;
  struct MonoType * D.29590;
  unsigned int D.29591;
  unsigned int D.29592;
  struct MonoArray * D.29595;
  struct MonoClass * D.29596;
  struct MonoGenericClass * D.29597;
  void * D.29600;
  unsigned int D.29601;
  unsigned int D.29602;
  unsigned int D.29605;
  unsigned int D.29609;
  struct MonoType * D.29614;
  int D.29615;
  int D.29616;
  unsigned int D.29619;
  unsigned int D.29620;
  int D.29621;
  void * D.29622;
  void * * D.29623;
  unsigned int D.29624;
  int D.29627;
  int D.29628;
  unsigned int D.29629;
  unsigned int D.29630;
  void * * D.29631;
  struct MonoClass * D.22078;
  struct MonoClass * tmp_klass.206;
  struct MonoClass * tmp_klass.207;
  _Bool D.29636;
  long int D.29637;
  long int D.29638;
  struct MonoVTable * D.29641;
  unsigned int D.29642;
  unsigned int i.208;
  unsigned int i.209;
  unsigned int D.29645;
  void * * D.29646;
  void * D.29647;
  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.29589 = MEM[(struct MonoObject *)type].vtable;
      domain = D.29589->domain;
      D.29590 = type->type;
      D.29591 = BIT_FIELD_REF <*D.29590, 32, 32>;
      D.29592 = D.29591 & 1073741824;
      if (D.29592 != 0) goto <D.29593>; else goto <D.29594>;
      <D.29593>:
      D.29596 = mono_defaults.monotype_class;
      D.29595 = mono_array_new (domain, D.29596, 0);
      return D.29595;
      <D.29594>:
      D.29590 = type->type;
      klass = mono_class_from_mono_type (D.29590);
      D.29597 = klass->generic_class;
      if (D.29597 != 0B) goto <D.29598>; else goto <D.29599>;
      <D.29598>:
      D.29597 = klass->generic_class;
      klass = D.29597->container_class;
      <D.29599>:
      tmp_array.size = 0;
      tmp_array.capacity = 16;
      D.29600 = __builtin_alloca (64);
      tmp_array.data = D.29600;
      iter = 0B;
      goto <D.22073>;
      <D.22075>:
      match = 0;
      D.29601 = nested->flags;
      D.29602 = D.29601 & 7;
      if (D.29602 == 2) goto <D.29603>; else goto <D.29604>;
      <D.29603>:
      D.29605 = bflags & 16;
      if (D.29605 != 0) goto <D.29606>; else goto <D.29607>;
      <D.29606>:
      match = match + 1;
      <D.29607>:
      goto <D.29608>;
      <D.29604>:
      D.29609 = bflags & 32;
      if (D.29609 != 0) goto <D.29610>; else goto <D.29611>;
      <D.29610>:
      match = match + 1;
      <D.29611>:
      <D.29608>:
      if (match == 0) goto <D.29612>; else goto <D.29613>;
      <D.29612>:
      // predicted unlikely by continue predictor.
      goto <D.22073>;
      <D.29613>:
      D.29614 = &nested->byval_arg;
      member = mono_type_get_object (domain, D.29614);
      D.29615 = tmp_array.size;
      D.29616 = tmp_array.capacity;
      if (D.29615 >= D.29616) goto <D.29617>; else goto <D.29618>;
      <D.29617>:
      {
        void * __tmp;

        D.29616 = tmp_array.capacity;
        D.29619 = (unsigned int) D.29616;
        D.29620 = D.29619 * 8;
        D.29616 = tmp_array.capacity;
        D.29621 = D.29616 * 2;
        D.29622 = mono_gc_make_root_descr_all_refs (D.29621);
        __tmp = mono_gc_alloc_fixed (D.29620, D.29622);
        D.29623 = tmp_array.data;
        D.29616 = tmp_array.capacity;
        D.29619 = (unsigned int) D.29616;
        D.29624 = D.29619 * 4;
        mono_gc_memmove_aligned (__tmp, D.29623, D.29624);
        D.29616 = tmp_array.capacity;
        if (D.29616 > 16) goto <D.29625>; else goto <D.29626>;
        <D.29625>:
        D.29623 = tmp_array.data;
        mono_gc_free_fixed (D.29623);
        <D.29626>:
        tmp_array.data = __tmp;
        D.29616 = tmp_array.capacity;
        D.29621 = D.29616 * 2;
        tmp_array.capacity = D.29621;
      }
      <D.29618>:
      D.29623 = tmp_array.data;
      D.29615 = tmp_array.size;
      D.29627 = D.29615;
      D.29628 = D.29627 + 1;
      tmp_array.size = D.29628;
      D.29629 = (unsigned int) D.29627;
      D.29630 = D.29629 * 4;
      D.29631 = D.29623 + D.29630;
      *D.29631 = member;
      <D.22073>:
      nested = mono_class_get_nested_types (klass, &iter);
      if (nested != 0B) goto <D.22075>; else goto <D.22076>;
      <D.22076>:
      {
        static struct MonoClass * tmp_klass;

        {
          tmp_klass.206 = tmp_klass;
          if (tmp_klass.206 == 0B) goto <D.29633>; else goto <D.29634>;
          <D.29633>:
          D.29596 = mono_defaults.monotype_class;
          tmp_klass.207 = mono_array_class_get (D.29596, 1);
          tmp_klass = tmp_klass.207;
          tmp_klass.206 = tmp_klass;
          D.29636 = tmp_klass.206 == 0B;
          D.29637 = (long int) D.29636;
          D.29638 = __builtin_expect (D.29637, 0);
          if (D.29638 != 0) goto <D.29639>; else goto <D.29640>;
          <D.29639>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "icall.c", 4094, "tmp_klass");
          <D.29640>:
          <D.29634>:
        }
        D.22078 = tmp_klass;
      }
      D.29641 = mono_class_vtable (domain, D.22078);
      D.29615 = tmp_array.size;
      D.29642 = (unsigned int) D.29615;
      res = mono_array_new_specific (D.29641, D.29642);
      i = 0;
      goto <D.22081>;
      <D.22080>:
      {
        void * * __p;

        i.208 = (unsigned int) i;
        __p = mono_array_addr_with_size (res, 4, i.208);
        D.29623 = tmp_array.data;
        i.209 = (unsigned int) i;
        D.29645 = i.209 * 4;
        D.29646 = D.29623 + D.29645;
        D.29647 = *D.29646;
        mono_gc_wbarrier_set_arrayref (res, __p, D.29647);
      }
      i = i + 1;
      <D.22081>:
      D.29615 = tmp_array.size;
      if (D.29615 > i) goto <D.22080>; else goto <D.22082>;
      <D.22082>:
      D.29616 = tmp_array.capacity;
      if (D.29616 > 16) goto <D.29648>; else goto <D.29649>;
      <D.29648>:
      D.29623 = tmp_array.data;
      mono_gc_free_fixed (D.29623);
      <D.29649>:
      D.29595 = res;
      return D.29595;
    }
  finally
    {
      iter = {CLOBBER};
      tmp_array = {CLOBBER};
    }
}


ves_icall_Type_GetNestedType (struct MonoReflectionType * type, struct MonoString * name, guint32 bflags)
{
  struct MonoException * D.29654;
  struct MonoVTable * D.29655;
  struct MonoType * D.29656;
  unsigned int D.29657;
  unsigned int D.29658;
  struct MonoReflectionType * D.29661;
  unsigned char D.29662;
  struct MonoException * D.29665;
  struct MonoGenericClass * D.29666;
  unsigned int D.29669;
  unsigned int D.29670;
  unsigned int D.29673;
  unsigned int D.29677;
  int D.22057;
  const char * D.29682;
  struct MonoType * D.29685;
  unsigned int D.29686;
  struct MonoDomain * domain;
  struct MonoClass * klass;
  struct MonoClass * nested;
  char * str;
  void * iter;
  void handle_parent = <<< error >>>;

  try
    {
      if (name == 0B) goto <D.29652>; else goto <D.29653>;
      <D.29652>:
      D.29654 = mono_get_exception_argument_null ("name");
      mono_raise_exception (D.29654);
      <D.29653>:
      D.29655 = MEM[(struct MonoObject *)type].vtable;
      domain = D.29655->domain;
      D.29656 = type->type;
      D.29657 = BIT_FIELD_REF <*D.29656, 32, 32>;
      D.29658 = D.29657 & 1073741824;
      if (D.29658 != 0) goto <D.29659>; else goto <D.29660>;
      <D.29659>:
      D.29661 = 0B;
      return D.29661;
      <D.29660>:
      D.29656 = type->type;
      klass = mono_class_from_mono_type (D.29656);
      str = mono_string_to_utf8 (name);
      handle_parent:
      D.29662 = klass->exception_type;
      if (D.29662 != 0) goto <D.29663>; else goto <D.29664>;
      <D.29663>:
      D.29665 = mono_class_get_exception_for_failure (klass);
      mono_raise_exception (D.29665);
      <D.29664>:
      D.29666 = klass->generic_class;
      if (D.29666 != 0B) goto <D.29667>; else goto <D.29668>;
      <D.29667>:
      D.29666 = klass->generic_class;
      klass = D.29666->container_class;
      <D.29668>:
      iter = 0B;
      goto <D.22048>;
      <D.22058>:
      {
        int match;

        match = 0;
        D.29669 = nested->flags;
        D.29670 = D.29669 & 7;
        if (D.29670 == 2) goto <D.29671>; else goto <D.29672>;
        <D.29671>:
        D.29673 = bflags & 16;
        if (D.29673 != 0) goto <D.29674>; else goto <D.29675>;
        <D.29674>:
        match = match + 1;
        <D.29675>:
        goto <D.29676>;
        <D.29672>:
        D.29677 = bflags & 32;
        if (D.29677 != 0) goto <D.29678>; else goto <D.29679>;
        <D.29678>:
        match = match + 1;
        <D.29679>:
        <D.29676>:
        if (match == 0) goto <D.29680>; else goto <D.29681>;
        <D.29680>:
        // predicted unlikely by continue predictor.
        goto <D.22048>;
        <D.29681>:
        {
          size_t __s1_len;
          size_t __s2_len;

          D.29682 = nested->name;
          D.22057 = __builtin_strcmp (D.29682, str);
        }
        if (D.22057 == 0) goto <D.29683>; else goto <D.29684>;
        <D.29683>:
        monoeg_g_free (str);
        D.29685 = &nested->byval_arg;
        D.29661 = mono_type_get_object (domain, D.29685);
        return D.29661;
        <D.29684>:
      }
      <D.22048>:
      nested = mono_class_get_nested_types (klass, &iter);
      if (nested != 0B) goto <D.22058>; else goto <D.22059>;
      <D.22059>:
      D.29686 = bflags & 2;
      if (D.29686 == 0) goto <D.29687>; else goto <D.29688>;
      <D.29687>:
      klass = klass->parent;
      if (klass != 0B) goto handle_parent; else goto <D.29689>;
      <D.29689>:
      <D.29688>:
      monoeg_g_free (str);
      D.29661 = 0B;
      return D.29661;
    }
  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.29695;
  struct MonoType * D.29696;
  struct MonoType * D.29697;
  struct MonoVTable * D.29698;
  unsigned int D.29699;
  unsigned int D.29700;
  struct MonoArray * D.29703;
  int D.29706;
  struct MonoException * ex.211;
  unsigned int D.29710;
  void * * D.29711;
  unsigned int i.212;
  unsigned int D.29713;
  void * * D.29714;
  unsigned int i.213;
  struct MonoReflectionMethod * D.29716;
  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.29693>; else goto <D.29694>;
      <D.29693>:
      {
        struct MonoClass * klass;

        D.29695 = mono_defaults.method_info_class;
        klass = mono_array_class_get (D.29695, 1);
        mono_memory_barrier ();
        MethodInfo_array = klass;
      }
      <D.29694>:
      D.29696 = type->type;
      klass = mono_class_from_mono_type (D.29696);
      D.29697 = reftype->type;
      refklass = mono_class_from_mono_type (D.29697);
      D.29698 = MEM[(struct MonoObject *)type].vtable;
      domain = D.29698->domain;
      MethodInfo_array.210 = MethodInfo_array;
      array_vtable = mono_class_vtable_full (domain, MethodInfo_array.210, 1);
      D.29696 = type->type;
      D.29699 = BIT_FIELD_REF <*D.29696, 32, 32>;
      D.29700 = D.29699 & 1073741824;
      if (D.29700 != 0) goto <D.29701>; else goto <D.29702>;
      <D.29701>:
      D.29703 = mono_array_new_specific (array_vtable, 0);
      return D.29703;
      <D.29702>:
      if (name != 0B) goto <D.29704>; else goto <D.29705>;
      <D.29704>:
      mname = mono_string_to_utf8 (name);
      <D.29705>:
      D.29706 = (int) ignore_case;
      method_array = mono_class_get_methods_by_name (klass, mname, bflags, D.29706, 0, &ex);
      monoeg_g_free (mname);
      ex.211 = ex;
      if (ex.211 != 0B) goto <D.29708>; else goto <D.29709>;
      <D.29708>:
      ex.211 = ex;
      mono_raise_exception (ex.211);
      <D.29709>:
      D.29710 = method_array->len;
      res = mono_array_new_specific (array_vtable, D.29710);
      i = 0;
      goto <D.21886>;
      <D.21885>:
      {
        struct MonoMethod * method;

        D.29711 = method_array->pdata;
        i.212 = (unsigned int) i;
        D.29713 = i.212 * 4;
        D.29714 = D.29711 + D.29713;
        method = *D.29714;
        {
          void * * __p;

          i.213 = (unsigned int) i;
          __p = mono_array_addr_with_size (res, 4, i.213);
          D.29716 = mono_method_get_object (domain, method, refklass);
          mono_gc_wbarrier_set_arrayref (res, __p, D.29716);
        }
      }
      i = i + 1;
      <D.21886>:
      i.214 = (unsigned int) i;
      D.29710 = method_array->len;
      if (i.214 < D.29710) goto <D.21885>; else goto <D.21887>;
      <D.21887>:
      monoeg_g_ptr_array_free (method_array, 1);
      D.29703 = res;
      return D.29703;
    }
  finally
    {
      ex = {CLOBBER};
    }
}


mono_memory_barrier ()
{
  __sync_synchronize ();
}


ves_icall_Type_GetInterfaces (struct MonoReflectionType * type)
{
  struct MonoType * D.29720;
  struct MonoGenericClass * D.29721;
  struct MonoGenericInst * D.29724;
  unsigned int D.29725;
  unsigned int D.29726;
  struct MonoGenericContext * D.29729;
  int D.29730;
  int D.29732;
  struct MonoVTable * D.29734;
  struct MonoDomain * D.29735;
  unsigned int D.29736;
  struct MonoDomain * D.29739;
  struct MonoArray * D.29740;
  struct MonoClass * D.21211;
  struct MonoClass * tmp_klass.215;
  struct MonoClass * D.29746;
  struct MonoClass * tmp_klass.216;
  _Bool D.29748;
  long int D.29749;
  long int D.29750;
  struct MonoVTable * D.29753;
  struct MonoArray * D.29754;
  struct MonoArray * D.29755;
  struct MonoClass * D.21213;
  struct MonoClass * tmp_klass.217;
  struct MonoClass * tmp_klass.218;
  _Bool D.29760;
  long int D.29761;
  long int D.29762;
  struct MonoVTable * D.29765;
  unsigned int len.219;
  struct MonoArray * D.29767;
  int D.29768;
  struct MonoError error;
  struct MonoClass * class;
  struct MonoClass * parent;
  struct FillIfaceArrayData data;
  int len;
  struct GHashTable * iface_hash;
  void fail = <<< error >>>;

  try
    {
      D.29720 = type->type;
      class = mono_class_from_mono_type (D.29720);
      data = {};
      iface_hash = monoeg_g_hash_table_new (0B, 0B);
      D.29721 = class->generic_class;
      if (D.29721 != 0B) goto <D.29722>; else goto <D.29723>;
      <D.29722>:
      D.29721 = class->generic_class;
      D.29724 = D.29721->context.class_inst;
      D.29725 = BIT_FIELD_REF <*D.29724, 32, 32>;
      D.29726 = D.29725 & 4194304;
      if (D.29726 != 0) goto <D.29727>; else goto <D.29728>;
      <D.29727>:
      D.29729 = mono_class_get_context (class);
      data.context = D.29729;
      D.29721 = class->generic_class;
      class = D.29721->container_class;
      <D.29728>:
      <D.29723>:
      parent = class;
      goto <D.21208>;
      <D.21207>:
      mono_class_setup_interfaces (parent, &error);
      D.29730 = mono_error_ok (&error);
      if (D.29730 == 0) goto fail; else goto <D.29731>;
      <D.29731>:
      collect_interfaces (parent, iface_hash, &error);
      D.29732 = mono_error_ok (&error);
      if (D.29732 == 0) goto fail; else goto <D.29733>;
      <D.29733>:
      parent = parent->parent;
      <D.21208>:
      if (parent != 0B) goto <D.21207>; else goto <D.21209>;
      <D.21209>:
      data.error = &error;
      D.29734 = MEM[(struct MonoObject *)type].vtable;
      D.29735 = D.29734->domain;
      data.domain = D.29735;
      D.29736 = monoeg_g_hash_table_size (iface_hash);
      len = (int) D.29736;
      if (len == 0) goto <D.29737>; else goto <D.29738>;
      <D.29737>:
      monoeg_g_hash_table_destroy (iface_hash);
      D.29739 = data.domain;
      D.29740 = D.29739->empty_types;
      if (D.29740 == 0B) goto <D.29741>; else goto <D.29742>;
      <D.29741>:
      D.29739 = data.domain;
      D.29739 = data.domain;
      {
        static struct MonoClass * tmp_klass;

        {
          tmp_klass.215 = tmp_klass;
          if (tmp_klass.215 == 0B) goto <D.29744>; else goto <D.29745>;
          <D.29744>:
          D.29746 = mono_defaults.monotype_class;
          tmp_klass.216 = mono_array_class_get (D.29746, 1);
          tmp_klass = tmp_klass.216;
          tmp_klass.215 = tmp_klass;
          D.29748 = tmp_klass.215 == 0B;
          D.29749 = (long int) D.29748;
          D.29750 = __builtin_expect (D.29749, 0);
          if (D.29750 != 0) goto <D.29751>; else goto <D.29752>;
          <D.29751>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "icall.c", 2107, "tmp_klass");
          <D.29752>:
          <D.29745>:
        }
        D.21211 = tmp_klass;
      }
      D.29753 = mono_class_vtable (D.29739, D.21211);
      D.29754 = mono_array_new_specific (D.29753, 0);
      D.29739->empty_types = D.29754;
      <D.29742>:
      D.29739 = data.domain;
      D.29755 = D.29739->empty_types;
      return D.29755;
      <D.29738>:
      D.29739 = data.domain;
      {
        static struct MonoClass * tmp_klass;

        {
          tmp_klass.217 = tmp_klass;
          if (tmp_klass.217 == 0B) goto <D.29757>; else goto <D.29758>;
          <D.29757>:
          D.29746 = mono_defaults.monotype_class;
          tmp_klass.218 = mono_array_class_get (D.29746, 1);
          tmp_klass = tmp_klass.218;
          tmp_klass.217 = tmp_klass;
          D.29760 = tmp_klass.217 == 0B;
          D.29761 = (long int) D.29760;
          D.29762 = __builtin_expect (D.29761, 0);
          if (D.29762 != 0) goto <D.29763>; else goto <D.29764>;
          <D.29763>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "icall.c", 2111, "tmp_klass");
          <D.29764>:
          <D.29758>:
        }
        D.21213 = tmp_klass;
      }
      D.29765 = mono_class_vtable (D.29739, D.21213);
      len.219 = (unsigned int) len;
      D.29767 = mono_array_new_specific (D.29765, len.219);
      data.iface_array = D.29767;
      monoeg_g_hash_table_foreach (iface_hash, fill_iface_array, &data);
      D.29768 = mono_error_ok (&error);
      if (D.29768 == 0) goto fail; else goto <D.29769>;
      <D.29769>:
      monoeg_g_hash_table_destroy (iface_hash);
      D.29755 = data.iface_array;
      return D.29755;
      fail:
      monoeg_g_hash_table_destroy (iface_hash);
      mono_error_raise_exception (&error);
      D.29755 = 0B;
      return D.29755;
    }
  finally
    {
      error = {CLOBBER};
      data = {CLOBBER};
    }
}


fill_iface_array (void * key, void * value, void * user_data)
{
  struct MonoError * D.29772;
  int D.29773;
  struct MonoGenericContext * D.29776;
  struct MonoGenericClass * D.29779;
  struct MonoGenericInst * D.29782;
  unsigned int D.29783;
  unsigned int D.29784;
  int D.29787;
  struct MonoArray * D.29790;
  int D.29791;
  int D.29792;
  int D.29793;
  unsigned int D.29794;
  struct MonoDomain * D.29795;
  struct MonoReflectionType * D.29796;
  struct FillIfaceArrayData * data;
  struct MonoClass * ic;
  struct MonoType * ret;
  struct MonoType * inflated;

  data = user_data;
  ic = key;
  ret = &ic->byval_arg;
  inflated = 0B;
  D.29772 = data->error;
  D.29773 = mono_error_ok (D.29772);
  if (D.29773 == 0) goto <D.29774>; else goto <D.29775>;
  <D.29774>:
  return;
  <D.29775>:
  D.29776 = data->context;
  if (D.29776 != 0B) goto <D.29777>; else goto <D.29778>;
  <D.29777>:
  D.29779 = ic->generic_class;
  if (D.29779 != 0B) goto <D.29780>; else goto <D.29781>;
  <D.29780>:
  D.29779 = ic->generic_class;
  D.29782 = D.29779->context.class_inst;
  D.29783 = BIT_FIELD_REF <*D.29782, 32, 32>;
  D.29784 = D.29783 & 4194304;
  if (D.29784 != 0) goto <D.29785>; else goto <D.29786>;
  <D.29785>:
  D.29776 = data->context;
  D.29772 = data->error;
  ret = mono_class_inflate_generic_type_checked (ret, D.29776, D.29772);
  inflated = ret;
  D.29772 = data->error;
  D.29787 = mono_error_ok (D.29772);
  if (D.29787 == 0) goto <D.29788>; else goto <D.29789>;
  <D.29788>:
  return;
  <D.29789>:
  <D.29786>:
  <D.29781>:
  <D.29778>:
  {
    void * * __p;

    D.29790 = data->iface_array;
    D.29791 = data->next_idx;
    D.29792 = D.29791;
    D.29793 = D.29792 + 1;
    data->next_idx = D.29793;
    D.29794 = (unsigned int) D.29792;
    __p = mono_array_addr_with_size (D.29790, 4, D.29794);
    D.29790 = data->iface_array;
    D.29795 = data->domain;
    D.29796 = mono_type_get_object (D.29795, ret);
    mono_gc_wbarrier_set_arrayref (D.29790, __p, D.29796);
  }
  if (inflated != 0B) goto <D.29797>; else goto <D.29798>;
  <D.29797>:
  mono_metadata_free_type (inflated);
  <D.29798>:
}


collect_interfaces (struct MonoClass * klass, struct GHashTable * ifaces, struct MonoError * error)
{
  int D.29800;
  struct MonoClass * * D.29803;
  unsigned int i.220;
  unsigned int D.29805;
  struct MonoClass * * D.29806;
  int D.29807;
  short unsigned int D.29810;
  int D.29811;
  int i;
  struct MonoClass * ic;

  mono_class_setup_interfaces (klass, error);
  D.29800 = mono_error_ok (error);
  if (D.29800 == 0) goto <D.29801>; else goto <D.29802>;
  <D.29801>:
  return;
  <D.29802>:
  i = 0;
  goto <D.21178>;
  <D.21177>:
  D.29803 = klass->interfaces;
  i.220 = (unsigned int) i;
  D.29805 = i.220 * 4;
  D.29806 = D.29803 + D.29805;
  ic = *D.29806;
  monoeg_g_hash_table_insert_replace (ifaces, ic, ic, 0);
  collect_interfaces (ic, ifaces, error);
  D.29807 = mono_error_ok (error);
  if (D.29807 == 0) goto <D.29808>; else goto <D.29809>;
  <D.29808>:
  return;
  <D.29809>:
  i = i + 1;
  <D.21178>:
  D.29810 = klass->interface_count;
  D.29811 = (int) D.29810;
  if (D.29811 > i) goto <D.21177>; else goto <D.21179>;
  <D.21179>:
}


ves_icall_MonoType_GetGenericArguments (struct MonoReflectionType * type)
{
  struct MonoVTable * D.29813;
  struct MonoClass * D.21305;
  struct MonoClass * tmp_klass.221;
  struct MonoClass * D.29817;
  struct MonoClass * tmp_klass.222;
  _Bool D.29819;
  long int D.29820;
  long int D.29821;
  struct MonoType * D.29824;
  struct MonoGenericContainer * D.29825;
  <unnamed-signed:31> D.29828;
  unsigned int D.29829;
  struct MonoGenericParamFull * D.29830;
  unsigned int i.223;
  unsigned int D.29832;
  struct MonoGenericParam * D.29833;
  struct MonoImage * D.29834;
  unsigned int i.224;
  struct MonoType * D.29836;
  struct MonoReflectionType * D.29837;
  int D.29838;
  struct MonoGenericClass * D.29840;
  <unnamed-unsigned:22> D.29843;
  unsigned int D.29844;
  struct MonoType * D.29845;
  struct MonoReflectionType * D.29846;
  int D.29847;
  struct MonoArray * D.29849;
  struct MonoArray * res;
  struct MonoClass * klass;
  struct MonoClass * pklass;
  struct MonoDomain * domain;
  struct MonoVTable * array_vtable;
  int i;

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

    {
      tmp_klass.221 = tmp_klass;
      if (tmp_klass.221 == 0B) goto <D.29815>; else goto <D.29816>;
      <D.29815>:
      D.29817 = mono_defaults.systemtype_class;
      tmp_klass.222 = mono_array_class_get (D.29817, 1);
      tmp_klass = tmp_klass.222;
      tmp_klass.221 = tmp_klass;
      D.29819 = tmp_klass.221 == 0B;
      D.29820 = (long int) D.29819;
      D.29821 = __builtin_expect (D.29820, 0);
      if (D.29821 != 0) goto <D.29822>; else goto <D.29823>;
      <D.29822>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "icall.c", 2329, "tmp_klass");
      <D.29823>:
      <D.29816>:
    }
    D.21305 = tmp_klass;
  }
  array_vtable = mono_class_vtable_full (domain, D.21305, 1);
  D.29824 = type->type;
  klass = mono_class_from_mono_type (D.29824);
  D.29825 = klass->generic_container;
  if (D.29825 != 0B) goto <D.29826>; else goto <D.29827>;
  <D.29826>:
  {
    struct MonoGenericContainer * container;

    container = klass->generic_container;
    D.29828 = container->type_argc;
    D.29829 = (unsigned int) D.29828;
    res = mono_array_new_specific (array_vtable, D.29829);
    i = 0;
    goto <D.21310>;
    <D.21309>:
    D.29830 = container->type_params;
    i.223 = (unsigned int) i;
    D.29832 = i.223 * 32;
    D.29833 = D.29830 + D.29832;
    D.29834 = klass->image;
    pklass = mono_class_from_generic_parameter (D.29833, D.29834, 0);
    {
      void * * __p;

      i.224 = (unsigned int) i;
      __p = mono_array_addr_with_size (res, 4, i.224);
      D.29836 = &pklass->byval_arg;
      D.29837 = mono_type_get_object (domain, D.29836);
      mono_gc_wbarrier_set_arrayref (res, __p, D.29837);
    }
    i = i + 1;
    <D.21310>:
    D.29828 = container->type_argc;
    D.29838 = (int) D.29828;
    if (D.29838 > i) goto <D.21309>; else goto <D.21311>;
    <D.21311>:
  }
  goto <D.29839>;
  <D.29827>:
  D.29840 = klass->generic_class;
  if (D.29840 != 0B) goto <D.29841>; else goto <D.29842>;
  <D.29841>:
  {
    struct MonoGenericInst * inst;

    D.29840 = klass->generic_class;
    inst = D.29840->context.class_inst;
    D.29843 = inst->type_argc;
    D.29844 = (unsigned int) D.29843;
    res = mono_array_new_specific (array_vtable, D.29844);
    i = 0;
    goto <D.21315>;
    <D.21314>:
    {
      void * * __p;

      i.224 = (unsigned int) i;
      __p = mono_array_addr_with_size (res, 4, i.224);
      D.29845 = inst->type_argv[i];
      D.29846 = mono_type_get_object (domain, D.29845);
      mono_gc_wbarrier_set_arrayref (res, __p, D.29846);
    }
    i = i + 1;
    <D.21315>:
    D.29843 = inst->type_argc;
    D.29847 = (int) D.29843;
    if (D.29847 > i) goto <D.21314>; else goto <D.21316>;
    <D.21316>:
  }
  goto <D.29848>;
  <D.29842>:
  res = mono_array_new_specific (array_vtable, 0);
  <D.29848>:
  <D.29839>:
  D.29849 = res;
  return D.29849;
}


ves_icall_Type_GetFields_internal (struct MonoReflectionType * type, guint32 bflags, struct MonoReflectionType * reftype)
{
  struct MonoVTable * D.29851;
  struct MonoType * D.29852;
  unsigned int D.29853;
  unsigned int D.29854;
  struct MonoArray * D.29857;
  struct MonoClass * D.29858;
  struct MonoType * D.29859;
  void * D.29860;
  unsigned char D.29861;
  int D.29864;
  void * * D.29867;
  struct MonoException * D.29868;
  unsigned int D.29869;
  int D.21794;
  int iftmp.225;
  int D.21793;
  const char[9] * D.29875;
  unsigned char D.29876;
  int D.29877;
  unsigned char D.29878;
  int D.29879;
  const unsigned char * D.29884;
  unsigned char D.29885;
  int D.29886;
  const unsigned char * D.29887;
  unsigned char D.29888;
  int D.29889;
  const unsigned char * D.29894;
  unsigned char D.29895;
  int D.29896;
  const unsigned char * D.29897;
  unsigned char D.29898;
  int D.29899;
  const unsigned char * D.29904;
  unsigned char D.29905;
  int D.29906;
  const unsigned char * D.29907;
  unsigned char D.29908;
  int D.29909;
  const char * D.29911;
  unsigned int D.29914;
  unsigned int D.29917;
  unsigned int D.29924;
  unsigned int D.29929;
  unsigned int D.29932;
  unsigned int D.29937;
  unsigned int D.29940;
  int D.29945;
  unsigned int D.29948;
  unsigned int D.29949;
  int D.29950;
  void * D.29951;
  unsigned int D.29952;
  int D.29955;
  int D.29956;
  unsigned int D.29957;
  unsigned int D.29958;
  void * * D.29959;
  unsigned int D.29960;
  struct MonoClass * D.21800;
  struct MonoClass * tmp_klass.226;
  struct MonoClass * tmp_klass.227;
  _Bool D.29968;
  long int D.29969;
  long int D.29970;
  struct MonoVTable * D.29973;
  unsigned int D.29974;
  unsigned int i.228;
  unsigned int i.229;
  unsigned int D.29977;
  void * * D.29978;
  void * D.29979;
  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.29851 = MEM[(struct MonoObject *)type].vtable;
      domain = D.29851->domain;
      D.29852 = type->type;
      D.29853 = BIT_FIELD_REF <*D.29852, 32, 32>;
      D.29854 = D.29853 & 1073741824;
      if (D.29854 != 0) goto <D.29855>; else goto <D.29856>;
      <D.29855>:
      D.29858 = mono_defaults.field_info_class;
      D.29857 = mono_array_new (domain, D.29858, 0);
      return D.29857;
      <D.29856>:
      D.29852 = type->type;
      startklass = mono_class_from_mono_type (D.29852);
      klass = startklass;
      D.29859 = reftype->type;
      refklass = mono_class_from_mono_type (D.29859);
      tmp_array.size = 0;
      tmp_array.capacity = 16;
      D.29860 = __builtin_alloca (64);
      tmp_array.data = D.29860;
      handle_parent:
      D.29861 = klass->exception_type;
      if (D.29861 != 0) goto <D.29862>; else goto <D.29863>;
      <D.29862>:
      D.29864 = tmp_array.capacity;
      if (D.29864 > 16) goto <D.29865>; else goto <D.29866>;
      <D.29865>:
      D.29867 = tmp_array.data;
      mono_gc_free_fixed (D.29867);
      <D.29866>:
      D.29868 = mono_class_get_exception_for_failure (klass);
      mono_raise_exception (D.29868);
      <D.29863>:
      iter = 0B;
      goto <D.21795>;
      <D.21797>:
      {
        guint32 flags;

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

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

            __s2 = mono_field_get_name (field);
            D.29875 = "_Deleted";
            D.29876 = MEM[(const unsigned char *)D.29875];
            D.29877 = (int) D.29876;
            D.29878 = *__s2;
            D.29879 = (int) D.29878;
            __result = D.29877 - D.29879;
            {
              if (__s2_len != 0) goto <D.29880>; else goto <D.29881>;
              <D.29880>:
              if (__result == 0) goto <D.29882>; else goto <D.29883>;
              <D.29882>:
              D.29884 = &MEM[(void *)"_Deleted" + 1B];
              D.29885 = *D.29884;
              D.29886 = (int) D.29885;
              D.29887 = __s2 + 1;
              D.29888 = *D.29887;
              D.29889 = (int) D.29888;
              __result = D.29886 - D.29889;
              if (__s2_len > 1) goto <D.29890>; else goto <D.29891>;
              <D.29890>:
              if (__result == 0) goto <D.29892>; else goto <D.29893>;
              <D.29892>:
              D.29894 = &MEM[(void *)"_Deleted" + 2B];
              D.29895 = *D.29894;
              D.29896 = (int) D.29895;
              D.29897 = __s2 + 2;
              D.29898 = *D.29897;
              D.29899 = (int) D.29898;
              __result = D.29896 - D.29899;
              if (__s2_len > 2) goto <D.29900>; else goto <D.29901>;
              <D.29900>:
              if (__result == 0) goto <D.29902>; else goto <D.29903>;
              <D.29902>:
              D.29904 = &MEM[(void *)"_Deleted" + 3B];
              D.29905 = *D.29904;
              D.29906 = (int) D.29905;
              D.29907 = __s2 + 3;
              D.29908 = *D.29907;
              D.29909 = (int) D.29908;
              __result = D.29906 - D.29909;
              <D.29903>:
              <D.29901>:
              <D.29893>:
              <D.29891>:
              <D.29883>:
              <D.29881>:
            }
            D.21793 = __result;
          }
          iftmp.225 = -D.21793;
          goto <D.29910>;
          <D.29874>:
          D.29911 = mono_field_get_name (field);
          iftmp.225 = __builtin_strcmp (D.29911, "_Deleted");
          <D.29910>:
          D.21794 = iftmp.225;
        }
        if (D.21794 == 0) goto <D.29912>; else goto <D.29913>;
        <D.29912>:
        // predicted unlikely by continue predictor.
        goto <D.21795>;
        <D.29913>:
        <D.29871>:
        D.29914 = flags & 7;
        if (D.29914 == 6) goto <D.29915>; else goto <D.29916>;
        <D.29915>:
        D.29917 = bflags & 16;
        if (D.29917 != 0) goto <D.29918>; else goto <D.29919>;
        <D.29918>:
        match = match + 1;
        <D.29919>:
        goto <D.29920>;
        <D.29916>:
        if (klass == startklass) goto <D.29921>; else goto <D.29923>;
        <D.29923>:
        D.29914 = flags & 7;
        if (D.29914 != 1) goto <D.29921>; else goto <D.29922>;
        <D.29921>:
        D.29924 = bflags & 32;
        if (D.29924 != 0) goto <D.29925>; else goto <D.29926>;
        <D.29925>:
        match = match + 1;
        <D.29926>:
        <D.29922>:
        <D.29920>:
        if (match == 0) goto <D.29927>; else goto <D.29928>;
        <D.29927>:
        // predicted unlikely by continue predictor.
        goto <D.21795>;
        <D.29928>:
        match = 0;
        D.29929 = flags & 16;
        if (D.29929 != 0) goto <D.29930>; else goto <D.29931>;
        <D.29930>:
        D.29932 = bflags & 8;
        if (D.29932 != 0) goto <D.29933>; else goto <D.29934>;
        <D.29933>:
        D.29937 = bflags & 64;
        if (D.29937 != 0) goto <D.29935>; else goto <D.29938>;
        <D.29938>:
        if (klass == startklass) goto <D.29935>; else goto <D.29936>;
        <D.29935>:
        match = match + 1;
        <D.29936>:
        <D.29934>:
        goto <D.29939>;
        <D.29931>:
        D.29940 = bflags & 4;
        if (D.29940 != 0) goto <D.29941>; else goto <D.29942>;
        <D.29941>:
        match = match + 1;
        <D.29942>:
        <D.29939>:
        if (match == 0) goto <D.29943>; else goto <D.29944>;
        <D.29943>:
        // predicted unlikely by continue predictor.
        goto <D.21795>;
        <D.29944>:
        member = mono_field_get_object (domain, refklass, field);
        D.29945 = tmp_array.size;
        D.29864 = tmp_array.capacity;
        if (D.29945 >= D.29864) goto <D.29946>; else goto <D.29947>;
        <D.29946>:
        {
          void * __tmp;

          D.29864 = tmp_array.capacity;
          D.29948 = (unsigned int) D.29864;
          D.29949 = D.29948 * 8;
          D.29864 = tmp_array.capacity;
          D.29950 = D.29864 * 2;
          D.29951 = mono_gc_make_root_descr_all_refs (D.29950);
          __tmp = mono_gc_alloc_fixed (D.29949, D.29951);
          D.29867 = tmp_array.data;
          D.29864 = tmp_array.capacity;
          D.29948 = (unsigned int) D.29864;
          D.29952 = D.29948 * 4;
          mono_gc_memmove_aligned (__tmp, D.29867, D.29952);
          D.29864 = tmp_array.capacity;
          if (D.29864 > 16) goto <D.29953>; else goto <D.29954>;
          <D.29953>:
          D.29867 = tmp_array.data;
          mono_gc_free_fixed (D.29867);
          <D.29954>:
          tmp_array.data = __tmp;
          D.29864 = tmp_array.capacity;
          D.29950 = D.29864 * 2;
          tmp_array.capacity = D.29950;
        }
        <D.29947>:
        D.29867 = tmp_array.data;
        D.29945 = tmp_array.size;
        D.29955 = D.29945;
        D.29956 = D.29955 + 1;
        tmp_array.size = D.29956;
        D.29957 = (unsigned int) D.29955;
        D.29958 = D.29957 * 4;
        D.29959 = D.29867 + D.29958;
        *D.29959 = member;
      }
      <D.21795>:
      field = mono_class_get_fields_lazy (klass, &iter);
      if (field != 0B) goto <D.21797>; else goto <D.21798>;
      <D.21798>:
      D.29960 = bflags & 2;
      if (D.29960 == 0) goto <D.29961>; else goto <D.29962>;
      <D.29961>:
      klass = klass->parent;
      if (klass != 0B) goto handle_parent; else goto <D.29963>;
      <D.29963>:
      <D.29962>:
      {
        static struct MonoClass * tmp_klass;

        {
          tmp_klass.226 = tmp_klass;
          if (tmp_klass.226 == 0B) goto <D.29965>; else goto <D.29966>;
          <D.29965>:
          D.29858 = mono_defaults.field_info_class;
          tmp_klass.227 = mono_array_class_get (D.29858, 1);
          tmp_klass = tmp_klass.227;
          tmp_klass.226 = tmp_klass;
          D.29968 = tmp_klass.226 == 0B;
          D.29969 = (long int) D.29968;
          D.29970 = __builtin_expect (D.29969, 0);
          if (D.29970 != 0) goto <D.29971>; else goto <D.29972>;
          <D.29971>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "icall.c", 3414, "tmp_klass");
          <D.29972>:
          <D.29966>:
        }
        D.21800 = tmp_klass;
      }
      D.29973 = mono_class_vtable (domain, D.21800);
      D.29945 = tmp_array.size;
      D.29974 = (unsigned int) D.29945;
      res = mono_array_new_specific (D.29973, D.29974);
      i = 0;
      goto <D.21803>;
      <D.21802>:
      {
        void * * __p;

        i.228 = (unsigned int) i;
        __p = mono_array_addr_with_size (res, 4, i.228);
        D.29867 = tmp_array.data;
        i.229 = (unsigned int) i;
        D.29977 = i.229 * 4;
        D.29978 = D.29867 + D.29977;
        D.29979 = *D.29978;
        mono_gc_wbarrier_set_arrayref (res, __p, D.29979);
      }
      i = i + 1;
      <D.21803>:
      D.29945 = tmp_array.size;
      if (D.29945 > i) goto <D.21802>; else goto <D.21804>;
      <D.21804>:
      D.29864 = tmp_array.capacity;
      if (D.29864 > 16) goto <D.29980>; else goto <D.29981>;
      <D.29980>:
      D.29867 = tmp_array.data;
      mono_gc_free_fixed (D.29867);
      <D.29981>:
      D.29857 = res;
      return D.29857;
    }
  finally
    {
      iter = {CLOBBER};
      tmp_array = {CLOBBER};
    }
}


ves_icall_Type_GetField (struct MonoReflectionType * type, struct MonoString * name, guint32 bflags)
{
  struct MonoVTable * D.29984;
  struct MonoType * D.29985;
  struct MonoException * D.29988;
  unsigned int D.29989;
  unsigned int D.29990;
  struct MonoReflectionField * D.29993;
  int (*<T3926>) (const char *, const char *) iftmp.230;
  unsigned int D.29995;
  unsigned char D.29999;
  struct MonoException * D.30002;
  unsigned int D.30003;
  int D.21764;
  int iftmp.231;
  int D.21763;
  const char[9] * D.30009;
  unsigned char D.30010;
  int D.30011;
  unsigned char D.30012;
  int D.30013;
  const unsigned char * D.30018;
  unsigned char D.30019;
  int D.30020;
  const unsigned char * D.30021;
  unsigned char D.30022;
  int D.30023;
  const unsigned char * D.30028;
  unsigned char D.30029;
  int D.30030;
  const unsigned char * D.30031;
  unsigned char D.30032;
  int D.30033;
  const unsigned char * D.30038;
  unsigned char D.30039;
  int D.30040;
  const unsigned char * D.30041;
  unsigned char D.30042;
  int D.30043;
  const char * D.30045;
  unsigned int D.30048;
  unsigned int D.30051;
  unsigned int D.30058;
  unsigned int D.30063;
  unsigned int D.30066;
  unsigned int D.30071;
  unsigned int D.30074;
  const char * D.30079;
  int D.30080;
  unsigned int D.30083;
  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.29984 = MEM[(struct MonoObject *)type].vtable;
      domain = D.29984->domain;
      D.29985 = type->type;
      startklass = mono_class_from_mono_type (D.29985);
      klass = startklass;
      if (name == 0B) goto <D.29986>; else goto <D.29987>;
      <D.29986>:
      D.29988 = mono_get_exception_argument_null ("name");
      mono_raise_exception (D.29988);
      <D.29987>:
      D.29985 = type->type;
      D.29989 = BIT_FIELD_REF <*D.29985, 32, 32>;
      D.29990 = D.29989 & 1073741824;
      if (D.29990 != 0) goto <D.29991>; else goto <D.29992>;
      <D.29991>:
      D.29993 = 0B;
      return D.29993;
      <D.29992>:
      D.29995 = bflags & 1;
      if (D.29995 != 0) goto <D.29996>; else goto <D.29997>;
      <D.29996>:
      iftmp.230 = monoeg_ascii_strcasecmp;
      goto <D.29998>;
      <D.29997>:
      iftmp.230 = strcmp;
      <D.29998>:
      compare_func = iftmp.230;
      handle_parent:
      D.29999 = klass->exception_type;
      if (D.29999 != 0) goto <D.30000>; else goto <D.30001>;
      <D.30000>:
      D.30002 = mono_class_get_exception_for_failure (klass);
      mono_raise_exception (D.30002);
      <D.30001>:
      iter = 0B;
      goto <D.21765>;
      <D.21766>:
      {
        guint32 flags;

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

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

            __s2 = mono_field_get_name (field);
            D.30009 = "_Deleted";
            D.30010 = MEM[(const unsigned char *)D.30009];
            D.30011 = (int) D.30010;
            D.30012 = *__s2;
            D.30013 = (int) D.30012;
            __result = D.30011 - D.30013;
            {
              if (__s2_len != 0) goto <D.30014>; else goto <D.30015>;
              <D.30014>:
              if (__result == 0) goto <D.30016>; else goto <D.30017>;
              <D.30016>:
              D.30018 = &MEM[(void *)"_Deleted" + 1B];
              D.30019 = *D.30018;
              D.30020 = (int) D.30019;
              D.30021 = __s2 + 1;
              D.30022 = *D.30021;
              D.30023 = (int) D.30022;
              __result = D.30020 - D.30023;
              if (__s2_len > 1) goto <D.30024>; else goto <D.30025>;
              <D.30024>:
              if (__result == 0) goto <D.30026>; else goto <D.30027>;
              <D.30026>:
              D.30028 = &MEM[(void *)"_Deleted" + 2B];
              D.30029 = *D.30028;
              D.30030 = (int) D.30029;
              D.30031 = __s2 + 2;
              D.30032 = *D.30031;
              D.30033 = (int) D.30032;
              __result = D.30030 - D.30033;
              if (__s2_len > 2) goto <D.30034>; else goto <D.30035>;
              <D.30034>:
              if (__result == 0) goto <D.30036>; else goto <D.30037>;
              <D.30036>:
              D.30038 = &MEM[(void *)"_Deleted" + 3B];
              D.30039 = *D.30038;
              D.30040 = (int) D.30039;
              D.30041 = __s2 + 3;
              D.30042 = *D.30041;
              D.30043 = (int) D.30042;
              __result = D.30040 - D.30043;
              <D.30037>:
              <D.30035>:
              <D.30027>:
              <D.30025>:
              <D.30017>:
              <D.30015>:
            }
            D.21763 = __result;
          }
          iftmp.231 = -D.21763;
          goto <D.30044>;
          <D.30008>:
          D.30045 = mono_field_get_name (field);
          iftmp.231 = __builtin_strcmp (D.30045, "_Deleted");
          <D.30044>:
          D.21764 = iftmp.231;
        }
        if (D.21764 == 0) goto <D.30046>; else goto <D.30047>;
        <D.30046>:
        // predicted unlikely by continue predictor.
        goto <D.21765>;
        <D.30047>:
        <D.30005>:
        D.30048 = flags & 7;
        if (D.30048 == 6) goto <D.30049>; else goto <D.30050>;
        <D.30049>:
        D.30051 = bflags & 16;
        if (D.30051 != 0) goto <D.30052>; else goto <D.30053>;
        <D.30052>:
        match = match + 1;
        <D.30053>:
        goto <D.30054>;
        <D.30050>:
        if (klass == startklass) goto <D.30055>; else goto <D.30057>;
        <D.30057>:
        D.30048 = flags & 7;
        if (D.30048 != 1) goto <D.30055>; else goto <D.30056>;
        <D.30055>:
        D.30058 = bflags & 32;
        if (D.30058 != 0) goto <D.30059>; else goto <D.30060>;
        <D.30059>:
        match = match + 1;
        <D.30060>:
        <D.30056>:
        <D.30054>:
        if (match == 0) goto <D.30061>; else goto <D.30062>;
        <D.30061>:
        // predicted unlikely by continue predictor.
        goto <D.21765>;
        <D.30062>:
        match = 0;
        D.30063 = flags & 16;
        if (D.30063 != 0) goto <D.30064>; else goto <D.30065>;
        <D.30064>:
        D.30066 = bflags & 8;
        if (D.30066 != 0) goto <D.30067>; else goto <D.30068>;
        <D.30067>:
        D.30071 = bflags & 64;
        if (D.30071 != 0) goto <D.30069>; else goto <D.30072>;
        <D.30072>:
        if (klass == startklass) goto <D.30069>; else goto <D.30070>;
        <D.30069>:
        match = match + 1;
        <D.30070>:
        <D.30068>:
        goto <D.30073>;
        <D.30065>:
        D.30074 = bflags & 4;
        if (D.30074 != 0) goto <D.30075>; else goto <D.30076>;
        <D.30075>:
        match = match + 1;
        <D.30076>:
        <D.30073>:
        if (match == 0) goto <D.30077>; else goto <D.30078>;
        <D.30077>:
        // predicted unlikely by continue predictor.
        goto <D.21765>;
        <D.30078>:
        utf8_name = mono_string_to_utf8 (name);
        D.30079 = mono_field_get_name (field);
        D.30080 = compare_func (D.30079, utf8_name);
        if (D.30080 != 0) goto <D.30081>; else goto <D.30082>;
        <D.30081>:
        monoeg_g_free (utf8_name);
        // predicted unlikely by continue predictor.
        goto <D.21765>;
        <D.30082>:
        monoeg_g_free (utf8_name);
        D.29993 = mono_field_get_object (domain, klass, field);
        return D.29993;
      }
      <D.21765>:
      field = mono_class_get_fields_lazy (klass, &iter);
      if (field != 0B) goto <D.21766>; else goto <D.21767>;
      <D.21767>:
      D.30083 = bflags & 2;
      if (D.30083 == 0) goto <D.30084>; else goto <D.30085>;
      <D.30084>:
      klass = klass->parent;
      if (klass != 0B) goto handle_parent; else goto <D.30086>;
      <D.30086>:
      <D.30085>:
      D.29993 = 0B;
      return D.29993;
    }
  finally
    {
      iter = {CLOBBER};
    }
}


ves_icall_Type_GetEvents_internal (struct MonoReflectionType * type, guint32 bflags, struct MonoReflectionType * reftype)
{
  void * D.30089;
  struct MonoClass * System_Reflection_EventInfo.232;
  struct MonoImage * D.30093;
  struct MonoClass * System_Reflection_EventInfo.233;
  struct MonoVTable * D.30095;
  struct MonoType * D.30096;
  unsigned int D.30097;
  unsigned int D.30098;
  struct MonoArray * D.30101;
  struct MonoClass * D.22023;
  struct MonoClass * tmp_klass.234;
  struct MonoClass * tmp_klass.235;
  _Bool D.30106;
  long int D.30107;
  long int D.30108;
  struct MonoVTable * D.30111;
  unsigned char D.30112;
  struct MonoLoaderError * D.30114;
  short unsigned int D.30122;
  int D.30123;
  int D.30124;
  unsigned int D.30127;
  unsigned int D.30134;
  int D.30144;
  unsigned int D.30147;
  unsigned int D.30152;
  unsigned int D.30155;
  int D.30163;
  int D.30164;
  unsigned int D.30167;
  unsigned int D.30168;
  int D.30169;
  void * D.30170;
  void * * D.30171;
  unsigned int D.30172;
  int D.30175;
  int D.30176;
  unsigned int D.30177;
  unsigned int D.30178;
  void * * D.30179;
  struct MonoReflectionEvent * D.30180;
  unsigned int D.30181;
  struct MonoClass * D.22031;
  struct MonoClass * tmp_klass.236;
  struct MonoClass * tmp_klass.237;
  _Bool D.30189;
  long int D.30190;
  long int D.30191;
  struct MonoVTable * D.30194;
  unsigned int D.30195;
  unsigned int i.238;
  unsigned int i.239;
  unsigned int D.30198;
  void * * D.30199;
  void * D.30200;
  struct MonoLoaderError * D.30208;
  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.30089 = __builtin_alloca (64);
      tmp_array.data = D.30089;
      System_Reflection_EventInfo.232 = System_Reflection_EventInfo;
      if (System_Reflection_EventInfo.232 == 0B) goto <D.30091>; else goto <D.30092>;
      <D.30091>:
      D.30093 = mono_defaults.corlib;
      System_Reflection_EventInfo.233 = mono_class_from_name (D.30093, "System.Reflection", "EventInfo");
      System_Reflection_EventInfo = System_Reflection_EventInfo.233;
      <D.30092>:
      D.30095 = MEM[(struct MonoObject *)type].vtable;
      domain = D.30095->domain;
      D.30096 = type->type;
      D.30097 = BIT_FIELD_REF <*D.30096, 32, 32>;
      D.30098 = D.30097 & 1073741824;
      if (D.30098 != 0) goto <D.30099>; else goto <D.30100>;
      <D.30099>:
      {
        static struct MonoClass * tmp_klass;

        {
          tmp_klass.234 = tmp_klass;
          if (tmp_klass.234 == 0B) goto <D.30103>; else goto <D.30104>;
          <D.30103>:
          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.30106 = tmp_klass.234 == 0B;
          D.30107 = (long int) D.30106;
          D.30108 = __builtin_expect (D.30107, 0);
          if (D.30108 != 0) goto <D.30109>; else goto <D.30110>;
          <D.30109>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "icall.c", 3914, "tmp_klass");
          <D.30110>:
          <D.30104>:
        }
        D.22023 = tmp_klass;
      }
      D.30111 = mono_class_vtable (domain, D.22023);
      D.30101 = mono_array_new_specific (D.30111, 0);
      return D.30101;
      <D.30100>:
      D.30096 = type->type;
      startklass = mono_class_from_mono_type (D.30096);
      klass = startklass;
      handle_parent:
      mono_class_setup_vtable (klass);
      D.30112 = klass->exception_type;
      if (D.30112 != 0) goto loader_error; else goto <D.30113>;
      <D.30113>:
      D.30114 = mono_loader_get_last_error ();
      if (D.30114 != 0B) goto loader_error; else goto <D.30115>;
      <D.30115>:
      iter = 0B;
      goto <D.22026>;
      <D.22028>:
      match = 0;
      method = event->add;
      if (method == 0B) goto <D.30116>; else goto <D.30117>;
      <D.30116>:
      method = event->remove;
      <D.30117>:
      if (method == 0B) goto <D.30118>; else goto <D.30119>;
      <D.30118>:
      method = event->raise;
      <D.30119>:
      if (method != 0B) goto <D.30120>; else goto <D.30121>;
      <D.30120>:
      D.30122 = method->flags;
      D.30123 = (int) D.30122;
      D.30124 = D.30123 & 7;
      if (D.30124 == 6) goto <D.30125>; else goto <D.30126>;
      <D.30125>:
      D.30127 = bflags & 16;
      if (D.30127 != 0) goto <D.30128>; else goto <D.30129>;
      <D.30128>:
      match = match + 1;
      <D.30129>:
      goto <D.30130>;
      <D.30126>:
      if (klass == startklass) goto <D.30131>; else goto <D.30133>;
      <D.30133>:
      D.30122 = method->flags;
      D.30123 = (int) D.30122;
      D.30124 = D.30123 & 7;
      if (D.30124 != 1) goto <D.30131>; else goto <D.30132>;
      <D.30131>:
      D.30134 = bflags & 32;
      if (D.30134 != 0) goto <D.30135>; else goto <D.30136>;
      <D.30135>:
      match = match + 1;
      <D.30136>:
      <D.30132>:
      <D.30130>:
      goto <D.30137>;
      <D.30121>:
      D.30134 = bflags & 32;
      if (D.30134 != 0) goto <D.30138>; else goto <D.30139>;
      <D.30138>:
      match = match + 1;
      <D.30139>:
      <D.30137>:
      if (match == 0) goto <D.30140>; else goto <D.30141>;
      <D.30140>:
      // predicted unlikely by continue predictor.
      goto <D.22026>;
      <D.30141>:
      match = 0;
      if (method != 0B) goto <D.30142>; else goto <D.30143>;
      <D.30142>:
      D.30122 = method->flags;
      D.30123 = (int) D.30122;
      D.30144 = D.30123 & 16;
      if (D.30144 != 0) goto <D.30145>; else goto <D.30146>;
      <D.30145>:
      D.30147 = bflags & 8;
      if (D.30147 != 0) goto <D.30148>; else goto <D.30149>;
      <D.30148>:
      D.30152 = bflags & 64;
      if (D.30152 != 0) goto <D.30150>; else goto <D.30153>;
      <D.30153>:
      if (klass == startklass) goto <D.30150>; else goto <D.30151>;
      <D.30150>:
      match = match + 1;
      <D.30151>:
      <D.30149>:
      goto <D.30154>;
      <D.30146>:
      D.30155 = bflags & 4;
      if (D.30155 != 0) goto <D.30156>; else goto <D.30157>;
      <D.30156>:
      match = match + 1;
      <D.30157>:
      <D.30154>:
      goto <D.30158>;
      <D.30143>:
      D.30155 = bflags & 4;
      if (D.30155 != 0) goto <D.30159>; else goto <D.30160>;
      <D.30159>:
      match = match + 1;
      <D.30160>:
      <D.30158>:
      if (match == 0) goto <D.30161>; else goto <D.30162>;
      <D.30161>:
      // predicted unlikely by continue predictor.
      goto <D.22026>;
      <D.30162>:
      D.30163 = tmp_array.size;
      D.30164 = tmp_array.capacity;
      if (D.30163 >= D.30164) goto <D.30165>; else goto <D.30166>;
      <D.30165>:
      {
        void * __tmp;

        D.30164 = tmp_array.capacity;
        D.30167 = (unsigned int) D.30164;
        D.30168 = D.30167 * 8;
        D.30164 = tmp_array.capacity;
        D.30169 = D.30164 * 2;
        D.30170 = mono_gc_make_root_descr_all_refs (D.30169);
        __tmp = mono_gc_alloc_fixed (D.30168, D.30170);
        D.30171 = tmp_array.data;
        D.30164 = tmp_array.capacity;
        D.30167 = (unsigned int) D.30164;
        D.30172 = D.30167 * 4;
        mono_gc_memmove_aligned (__tmp, D.30171, D.30172);
        D.30164 = tmp_array.capacity;
        if (D.30164 > 16) goto <D.30173>; else goto <D.30174>;
        <D.30173>:
        D.30171 = tmp_array.data;
        mono_gc_free_fixed (D.30171);
        <D.30174>:
        tmp_array.data = __tmp;
        D.30164 = tmp_array.capacity;
        D.30169 = D.30164 * 2;
        tmp_array.capacity = D.30169;
      }
      <D.30166>:
      D.30171 = tmp_array.data;
      D.30163 = tmp_array.size;
      D.30175 = D.30163;
      D.30176 = D.30175 + 1;
      tmp_array.size = D.30176;
      D.30177 = (unsigned int) D.30175;
      D.30178 = D.30177 * 4;
      D.30179 = D.30171 + D.30178;
      D.30180 = mono_event_get_object (domain, startklass, event);
      *D.30179 = D.30180;
      <D.22026>:
      event = mono_class_get_events (klass, &iter);
      if (event != 0B) goto <D.22028>; else goto <D.22029>;
      <D.22029>:
      D.30181 = bflags & 2;
      if (D.30181 == 0) goto <D.30182>; else goto <D.30183>;
      <D.30182>:
      klass = klass->parent;
      if (klass != 0B) goto handle_parent; else goto <D.30184>;
      <D.30184>:
      <D.30183>:
      {
        static struct MonoClass * tmp_klass;

        {
          tmp_klass.236 = tmp_klass;
          if (tmp_klass.236 == 0B) goto <D.30186>; else goto <D.30187>;
          <D.30186>:
          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.30189 = tmp_klass.236 == 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", 3965, "tmp_klass");
          <D.30193>:
          <D.30187>:
        }
        D.22031 = tmp_klass;
      }
      D.30194 = mono_class_vtable (domain, D.22031);
      D.30163 = tmp_array.size;
      D.30195 = (unsigned int) D.30163;
      res = mono_array_new_specific (D.30194, D.30195);
      i = 0;
      goto <D.22034>;
      <D.22033>:
      {
        void * * __p;

        i.238 = (unsigned int) i;
        __p = mono_array_addr_with_size (res, 4, i.238);
        D.30171 = tmp_array.data;
        i.239 = (unsigned int) i;
        D.30198 = i.239 * 4;
        D.30199 = D.30171 + D.30198;
        D.30200 = *D.30199;
        mono_gc_wbarrier_set_arrayref (res, __p, D.30200);
      }
      i = i + 1;
      <D.22034>:
      D.30163 = tmp_array.size;
      if (D.30163 > i) goto <D.22033>; else goto <D.22035>;
      <D.22035>:
      D.30164 = tmp_array.capacity;
      if (D.30164 > 16) goto <D.30201>; else goto <D.30202>;
      <D.30201>:
      D.30171 = tmp_array.data;
      mono_gc_free_fixed (D.30171);
      <D.30202>:
      D.30101 = res;
      return D.30101;
      loader_error:
      D.30164 = tmp_array.capacity;
      if (D.30164 > 16) goto <D.30203>; else goto <D.30204>;
      <D.30203>:
      D.30171 = tmp_array.data;
      mono_gc_free_fixed (D.30171);
      <D.30204>:
      D.30112 = klass->exception_type;
      if (D.30112 != 0) goto <D.30205>; else goto <D.30206>;
      <D.30205>:
      ex = mono_class_get_exception_for_failure (klass);
      goto <D.30207>;
      <D.30206>:
      D.30208 = mono_loader_get_last_error ();
      ex = mono_loader_error_prepare_exception (D.30208);
      mono_loader_clear_error ();
      <D.30207>:
      mono_raise_exception (ex);
      D.30101 = 0B;
      return D.30101;
    }
  finally
    {
      iter = {CLOBBER};
      tmp_array = {CLOBBER};
    }
}


ves_icall_MonoType_GetElementType (struct MonoReflectionType * type)
{
  struct MonoType * D.30211;
  unsigned int D.30212;
  unsigned int D.30213;
  struct MonoReflectionType * D.30216;
  struct MonoVTable * D.30217;
  struct MonoDomain * D.30218;
  struct MonoClass * D.30219;
  struct MonoType * D.30220;
  unsigned int D.30221;
  struct MonoType * D.30224;
  struct MonoClass * D.30226;
  unsigned char D.30228;
  struct MonoType * D.30230;
  unsigned char D.30233;
  struct MonoClass * class;

  D.30211 = type->type;
  D.30212 = BIT_FIELD_REF <*D.30211, 32, 32>;
  D.30213 = D.30212 & 1090453504;
  if (D.30213 == 1900544) goto <D.30214>; else goto <D.30215>;
  <D.30214>:
  D.30217 = MEM[(struct MonoObject *)type].vtable;
  D.30218 = D.30217->domain;
  D.30211 = type->type;
  D.30219 = D.30211->data.klass;
  D.30220 = &D.30219->byval_arg;
  D.30216 = mono_type_get_object (D.30218, D.30220);
  return D.30216;
  <D.30215>:
  D.30211 = type->type;
  class = mono_class_from_mono_type (D.30211);
  mono_class_init_or_throw (class);
  D.30211 = type->type;
  D.30212 = BIT_FIELD_REF <*D.30211, 32, 32>;
  D.30221 = D.30212 & 1073741824;
  if (D.30221 != 0) goto <D.30222>; else goto <D.30223>;
  <D.30222>:
  D.30217 = MEM[(struct MonoObject *)type].vtable;
  D.30218 = D.30217->domain;
  D.30224 = &class->byval_arg;
  D.30216 = mono_type_get_object (D.30218, D.30224);
  return D.30216;
  <D.30223>:
  D.30226 = class->element_class;
  if (D.30226 != 0B) goto <D.30227>; else goto <D.30225>;
  <D.30227>:
  D.30228 = class->rank;
  if (D.30228 != 0) goto <D.30229>; else goto <D.30225>;
  <D.30229>:
  D.30217 = MEM[(struct MonoObject *)type].vtable;
  D.30218 = D.30217->domain;
  D.30226 = class->element_class;
  D.30230 = &D.30226->byval_arg;
  D.30216 = mono_type_get_object (D.30218, D.30230);
  return D.30216;
  <D.30225>:
  D.30226 = class->element_class;
  if (D.30226 != 0B) goto <D.30232>; else goto <D.30231>;
  <D.30232>:
  D.30211 = type->type;
  D.30233 = D.30211->type;
  if (D.30233 == 15) goto <D.30234>; else goto <D.30231>;
  <D.30234>:
  D.30217 = MEM[(struct MonoObject *)type].vtable;
  D.30218 = D.30217->domain;
  D.30226 = class->element_class;
  D.30230 = &D.30226->byval_arg;
  D.30216 = mono_type_get_object (D.30218, D.30230);
  return D.30216;
  <D.30231>:
  D.30216 = 0B;
  return D.30216;
}


ves_icall_MonoType_GetCorrespondingInflatedMethod (struct MonoReflectionType * type, struct MonoReflectionMethod * generic)
{
  struct MonoVTable * D.30236;
  struct MonoType * D.30237;
  unsigned int D.30238;
  struct MonoMethod * D.30239;
  unsigned int D.30240;
  struct MonoReflectionMethod * D.30243;
  struct MonoDomain * domain;
  struct MonoClass * klass;
  struct MonoMethod * method;
  void * iter;

  try
    {
      D.30236 = MEM[(struct MonoObject *)type].vtable;
      domain = D.30236->domain;
      D.30237 = type->type;
      klass = mono_class_from_mono_type (D.30237);
      mono_class_init_or_throw (klass);
      iter = 0B;
      goto <D.21389>;
      <D.21388>:
      D.30238 = method->token;
      D.30239 = generic->method;
      D.30240 = D.30239->token;
      if (D.30238 == D.30240) goto <D.30241>; else goto <D.30242>;
      <D.30241>:
      D.30243 = mono_method_get_object (domain, method, klass);
      return D.30243;
      <D.30242>:
      <D.21389>:
      method = mono_class_get_methods (klass, &iter);
      if (method != 0B) goto <D.21388>; else goto <D.21390>;
      <D.21390>:
      D.30243 = 0B;
      return D.30243;
    }
  finally
    {
      iter = {CLOBBER};
    }
}


ves_icall_Type_GetConstructors_internal (struct MonoReflectionType * type, guint32 bflags, struct MonoReflectionType * reftype)
{
  void * D.30246;
  struct MonoVTable * D.30247;
  struct MonoType * D.30248;
  unsigned int D.30249;
  unsigned int D.30250;
  struct MonoArray * D.30253;
  struct MonoClass * D.21906;
  struct MonoClass * tmp_klass.240;
  struct MonoClass * D.30257;
  struct MonoClass * tmp_klass.241;
  _Bool D.30259;
  long int D.30260;
  long int D.30261;
  struct MonoVTable * D.30264;
  struct MonoType * D.30265;
  struct MonoClass * System_Reflection_ConstructorInfo.242;
  struct MonoImage * D.30269;
  struct MonoClass * System_Reflection_ConstructorInfo.243;
  int D.21915;
  int iftmp.244;
  int D.21914;
  const char[6] * D.30274;
  unsigned char D.30275;
  int D.30276;
  unsigned char D.30277;
  int D.30278;
  const unsigned char * D.30283;
  unsigned char D.30284;
  int D.30285;
  const unsigned char * D.30286;
  unsigned char D.30287;
  int D.30288;
  const unsigned char * D.30293;
  unsigned char D.30294;
  int D.30295;
  const unsigned char * D.30296;
  unsigned char D.30297;
  int D.30298;
  const unsigned char * D.30303;
  unsigned char D.30304;
  int D.30305;
  const unsigned char * D.30306;
  unsigned char D.30307;
  int D.30308;
  const char * D.30310;
  int D.21924;
  int iftmp.245;
  int D.21923;
  const char[7] * D.30316;
  unsigned char D.30317;
  int D.30318;
  unsigned char D.30319;
  int D.30320;
  const unsigned char * D.30325;
  unsigned char D.30326;
  int D.30327;
  const unsigned char * D.30328;
  unsigned char D.30329;
  int D.30330;
  const unsigned char * D.30335;
  unsigned char D.30336;
  int D.30337;
  const unsigned char * D.30338;
  unsigned char D.30339;
  int D.30340;
  const unsigned char * D.30345;
  unsigned char D.30346;
  int D.30347;
  const unsigned char * D.30348;
  unsigned char D.30349;
  int D.30350;
  short unsigned int D.30354;
  int D.30355;
  int D.30356;
  unsigned int D.30359;
  unsigned int D.30363;
  int D.30368;
  unsigned int D.30371;
  unsigned int D.30376;
  unsigned int D.30379;
  int D.30384;
  int D.30385;
  unsigned int D.30388;
  unsigned int D.30389;
  int D.30390;
  void * D.30391;
  void * * D.30392;
  unsigned int D.30393;
  int D.30396;
  int D.30397;
  unsigned int D.30398;
  unsigned int D.30399;
  void * * D.30400;
  struct MonoClass * D.21930;
  struct MonoClass * tmp_klass.246;
  struct MonoClass * tmp_klass.247;
  _Bool D.30405;
  long int D.30406;
  long int D.30407;
  struct MonoVTable * D.30410;
  unsigned int D.30411;
  unsigned int i.248;
  unsigned int i.249;
  unsigned int D.30414;
  void * * D.30415;
  void * D.30416;
  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.30246 = __builtin_alloca (64);
      tmp_array.data = D.30246;
      D.30247 = MEM[(struct MonoObject *)type].vtable;
      domain = D.30247->domain;
      D.30248 = type->type;
      D.30249 = BIT_FIELD_REF <*D.30248, 32, 32>;
      D.30250 = D.30249 & 1073741824;
      if (D.30250 != 0) goto <D.30251>; else goto <D.30252>;
      <D.30251>:
      {
        static struct MonoClass * tmp_klass;

        {
          tmp_klass.240 = tmp_klass;
          if (tmp_klass.240 == 0B) goto <D.30255>; else goto <D.30256>;
          <D.30255>:
          D.30257 = mono_defaults.method_info_class;
          tmp_klass.241 = mono_array_class_get (D.30257, 1);
          tmp_klass = tmp_klass.241;
          tmp_klass.240 = tmp_klass;
          D.30259 = tmp_klass.240 == 0B;
          D.30260 = (long int) D.30259;
          D.30261 = __builtin_expect (D.30260, 0);
          if (D.30261 != 0) goto <D.30262>; else goto <D.30263>;
          <D.30262>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "icall.c", 3617, "tmp_klass");
          <D.30263>:
          <D.30256>:
        }
        D.21906 = tmp_klass;
      }
      D.30264 = mono_class_vtable (domain, D.21906);
      D.30253 = mono_array_new_specific (D.30264, 0);
      return D.30253;
      <D.30252>:
      D.30248 = type->type;
      startklass = mono_class_from_mono_type (D.30248);
      klass = startklass;
      D.30265 = reftype->type;
      refklass = mono_class_from_mono_type (D.30265);
      System_Reflection_ConstructorInfo.242 = System_Reflection_ConstructorInfo;
      if (System_Reflection_ConstructorInfo.242 == 0B) goto <D.30267>; else goto <D.30268>;
      <D.30267>:
      D.30269 = mono_defaults.corlib;
      System_Reflection_ConstructorInfo.243 = mono_class_from_name (D.30269, "System.Reflection", "ConstructorInfo");
      System_Reflection_ConstructorInfo = System_Reflection_ConstructorInfo.243;
      <D.30268>:
      iter = 0B;
      goto <D.21925>;
      <D.21927>:
      match = 0;
      {
        size_t __s1_len;
        size_t __s2_len;

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

          __s2 = method->name;
          D.30274 = ".ctor";
          D.30275 = MEM[(const unsigned char *)D.30274];
          D.30276 = (int) D.30275;
          D.30277 = *__s2;
          D.30278 = (int) D.30277;
          __result = D.30276 - D.30278;
          {
            if (__s2_len != 0) goto <D.30279>; else goto <D.30280>;
            <D.30279>:
            if (__result == 0) goto <D.30281>; else goto <D.30282>;
            <D.30281>:
            D.30283 = &MEM[(void *)".ctor" + 1B];
            D.30284 = *D.30283;
            D.30285 = (int) D.30284;
            D.30286 = __s2 + 1;
            D.30287 = *D.30286;
            D.30288 = (int) D.30287;
            __result = D.30285 - D.30288;
            if (__s2_len > 1) goto <D.30289>; else goto <D.30290>;
            <D.30289>:
            if (__result == 0) goto <D.30291>; else goto <D.30292>;
            <D.30291>:
            D.30293 = &MEM[(void *)".ctor" + 2B];
            D.30294 = *D.30293;
            D.30295 = (int) D.30294;
            D.30296 = __s2 + 2;
            D.30297 = *D.30296;
            D.30298 = (int) D.30297;
            __result = D.30295 - D.30298;
            if (__s2_len > 2) goto <D.30299>; else goto <D.30300>;
            <D.30299>:
            if (__result == 0) goto <D.30301>; else goto <D.30302>;
            <D.30301>:
            D.30303 = &MEM[(void *)".ctor" + 3B];
            D.30304 = *D.30303;
            D.30305 = (int) D.30304;
            D.30306 = __s2 + 3;
            D.30307 = *D.30306;
            D.30308 = (int) D.30307;
            __result = D.30305 - D.30308;
            <D.30302>:
            <D.30300>:
            <D.30292>:
            <D.30290>:
            <D.30282>:
            <D.30280>:
          }
          D.21914 = __result;
        }
        iftmp.244 = -D.21914;
        goto <D.30309>;
        <D.30273>:
        D.30310 = method->name;
        iftmp.244 = __builtin_strcmp (D.30310, ".ctor");
        <D.30309>:
        D.21915 = iftmp.244;
      }
      if (D.21915 != 0) goto <D.30311>; else goto <D.30312>;
      <D.30311>:
      {
        size_t __s1_len;
        size_t __s2_len;

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

          __s2 = method->name;
          D.30316 = ".cctor";
          D.30317 = MEM[(const unsigned char *)D.30316];
          D.30318 = (int) D.30317;
          D.30319 = *__s2;
          D.30320 = (int) D.30319;
          __result = D.30318 - D.30320;
          {
            if (__s2_len != 0) goto <D.30321>; else goto <D.30322>;
            <D.30321>:
            if (__result == 0) goto <D.30323>; else goto <D.30324>;
            <D.30323>:
            D.30325 = &MEM[(void *)".cctor" + 1B];
            D.30326 = *D.30325;
            D.30327 = (int) D.30326;
            D.30328 = __s2 + 1;
            D.30329 = *D.30328;
            D.30330 = (int) D.30329;
            __result = D.30327 - D.30330;
            if (__s2_len > 1) goto <D.30331>; else goto <D.30332>;
            <D.30331>:
            if (__result == 0) goto <D.30333>; else goto <D.30334>;
            <D.30333>:
            D.30335 = &MEM[(void *)".cctor" + 2B];
            D.30336 = *D.30335;
            D.30337 = (int) D.30336;
            D.30338 = __s2 + 2;
            D.30339 = *D.30338;
            D.30340 = (int) D.30339;
            __result = D.30337 - D.30340;
            if (__s2_len > 2) goto <D.30341>; else goto <D.30342>;
            <D.30341>:
            if (__result == 0) goto <D.30343>; else goto <D.30344>;
            <D.30343>:
            D.30345 = &MEM[(void *)".cctor" + 3B];
            D.30346 = *D.30345;
            D.30347 = (int) D.30346;
            D.30348 = __s2 + 3;
            D.30349 = *D.30348;
            D.30350 = (int) D.30349;
            __result = D.30347 - D.30350;
            <D.30344>:
            <D.30342>:
            <D.30334>:
            <D.30332>:
            <D.30324>:
            <D.30322>:
          }
          D.21923 = __result;
        }
        iftmp.245 = -D.21923;
        goto <D.30351>;
        <D.30315>:
        D.30310 = method->name;
        iftmp.245 = __builtin_strcmp (D.30310, ".cctor");
        <D.30351>:
        D.21924 = iftmp.245;
      }
      if (D.21924 != 0) goto <D.30352>; else goto <D.30353>;
      <D.30352>:
      // predicted unlikely by continue predictor.
      goto <D.21925>;
      <D.30353>:
      <D.30312>:
      D.30354 = method->flags;
      D.30355 = (int) D.30354;
      D.30356 = D.30355 & 7;
      if (D.30356 == 6) goto <D.30357>; else goto <D.30358>;
      <D.30357>:
      D.30359 = bflags & 16;
      if (D.30359 != 0) goto <D.30360>; else goto <D.30361>;
      <D.30360>:
      match = match + 1;
      <D.30361>:
      goto <D.30362>;
      <D.30358>:
      D.30363 = bflags & 32;
      if (D.30363 != 0) goto <D.30364>; else goto <D.30365>;
      <D.30364>:
      match = match + 1;
      <D.30365>:
      <D.30362>:
      if (match == 0) goto <D.30366>; else goto <D.30367>;
      <D.30366>:
      // predicted unlikely by continue predictor.
      goto <D.21925>;
      <D.30367>:
      match = 0;
      D.30354 = method->flags;
      D.30355 = (int) D.30354;
      D.30368 = D.30355 & 16;
      if (D.30368 != 0) goto <D.30369>; else goto <D.30370>;
      <D.30369>:
      D.30371 = bflags & 8;
      if (D.30371 != 0) goto <D.30372>; else goto <D.30373>;
      <D.30372>:
      D.30376 = bflags & 64;
      if (D.30376 != 0) goto <D.30374>; else goto <D.30377>;
      <D.30377>:
      if (klass == startklass) goto <D.30374>; else goto <D.30375>;
      <D.30374>:
      match = match + 1;
      <D.30375>:
      <D.30373>:
      goto <D.30378>;
      <D.30370>:
      D.30379 = bflags & 4;
      if (D.30379 != 0) goto <D.30380>; else goto <D.30381>;
      <D.30380>:
      match = match + 1;
      <D.30381>:
      <D.30378>:
      if (match == 0) goto <D.30382>; else goto <D.30383>;
      <D.30382>:
      // predicted unlikely by continue predictor.
      goto <D.21925>;
      <D.30383>:
      member = mono_method_get_object (domain, method, refklass);
      D.30384 = tmp_array.size;
      D.30385 = tmp_array.capacity;
      if (D.30384 >= D.30385) goto <D.30386>; else goto <D.30387>;
      <D.30386>:
      {
        void * __tmp;

        D.30385 = tmp_array.capacity;
        D.30388 = (unsigned int) D.30385;
        D.30389 = D.30388 * 8;
        D.30385 = tmp_array.capacity;
        D.30390 = D.30385 * 2;
        D.30391 = mono_gc_make_root_descr_all_refs (D.30390);
        __tmp = mono_gc_alloc_fixed (D.30389, D.30391);
        D.30392 = tmp_array.data;
        D.30385 = tmp_array.capacity;
        D.30388 = (unsigned int) D.30385;
        D.30393 = D.30388 * 4;
        mono_gc_memmove_aligned (__tmp, D.30392, D.30393);
        D.30385 = tmp_array.capacity;
        if (D.30385 > 16) goto <D.30394>; else goto <D.30395>;
        <D.30394>:
        D.30392 = tmp_array.data;
        mono_gc_free_fixed (D.30392);
        <D.30395>:
        tmp_array.data = __tmp;
        D.30385 = tmp_array.capacity;
        D.30390 = D.30385 * 2;
        tmp_array.capacity = D.30390;
      }
      <D.30387>:
      D.30392 = tmp_array.data;
      D.30384 = tmp_array.size;
      D.30396 = D.30384;
      D.30397 = D.30396 + 1;
      tmp_array.size = D.30397;
      D.30398 = (unsigned int) D.30396;
      D.30399 = D.30398 * 4;
      D.30400 = D.30392 + D.30399;
      *D.30400 = member;
      <D.21925>:
      method = mono_class_get_methods (klass, &iter);
      if (method != 0B) goto <D.21927>; else goto <D.21928>;
      <D.21928>:
      {
        static struct MonoClass * tmp_klass;

        {
          tmp_klass.246 = tmp_klass;
          if (tmp_klass.246 == 0B) goto <D.30402>; else goto <D.30403>;
          <D.30402>:
          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.30405 = tmp_klass.246 == 0B;
          D.30406 = (long int) D.30405;
          D.30407 = __builtin_expect (D.30406, 0);
          if (D.30407 != 0) goto <D.30408>; else goto <D.30409>;
          <D.30408>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "icall.c", 3656, "tmp_klass");
          <D.30409>:
          <D.30403>:
        }
        D.21930 = tmp_klass;
      }
      D.30410 = mono_class_vtable (domain, D.21930);
      D.30384 = tmp_array.size;
      D.30411 = (unsigned int) D.30384;
      res = mono_array_new_specific (D.30410, D.30411);
      i = 0;
      goto <D.21933>;
      <D.21932>:
      {
        void * * __p;

        i.248 = (unsigned int) i;
        __p = mono_array_addr_with_size (res, 4, i.248);
        D.30392 = tmp_array.data;
        i.249 = (unsigned int) i;
        D.30414 = i.249 * 4;
        D.30415 = D.30392 + D.30414;
        D.30416 = *D.30415;
        mono_gc_wbarrier_set_arrayref (res, __p, D.30416);
      }
      i = i + 1;
      <D.21933>:
      D.30384 = tmp_array.size;
      if (D.30384 > i) goto <D.21932>; else goto <D.21934>;
      <D.21934>:
      D.30385 = tmp_array.capacity;
      if (D.30385 > 16) goto <D.30417>; else goto <D.30418>;
      <D.30417>:
      D.30392 = tmp_array.data;
      mono_gc_free_fixed (D.30392);
      <D.30418>:
      D.30253 = res;
      return D.30253;
    }
  finally
    {
      iter = {CLOBBER};
      tmp_array = {CLOBBER};
    }
}


ves_icall_MonoType_GetArrayRank (struct MonoReflectionType * type)
{
  struct MonoType * D.30421;
  unsigned char D.30422;
  struct MonoException * D.30427;
  gint32 D.30428;
  unsigned char D.30429;
  struct MonoClass * class;

  D.30421 = type->type;
  D.30422 = D.30421->type;
  if (D.30422 != 20) goto <D.30423>; else goto <D.30424>;
  <D.30423>:
  D.30421 = type->type;
  D.30422 = D.30421->type;
  if (D.30422 != 29) goto <D.30425>; else goto <D.30426>;
  <D.30425>:
  D.30427 = mono_get_exception_argument ("type", "Type must be an array type");
  mono_raise_exception (D.30427);
  <D.30426>:
  <D.30424>:
  D.30421 = type->type;
  class = mono_class_from_mono_type (D.30421);
  D.30429 = class->rank;
  D.30428 = (gint32) D.30429;
  return D.30428;
}


ves_icall_get_enum_info (struct MonoReflectionType * type, struct MonoEnumInfo * info)
{
  struct MonoVTable * D.30431;
  struct MonoType * D.30432;
  struct MonoReflectionType * * D.30433;
  struct MonoType * D.30434;
  struct MonoReflectionType * D.30435;
  guint iftmp.250;
  int D.30437;
  int D.30440;
  int D.30441;
  struct MonoArray * * D.30443;
  struct MonoClass * D.30444;
  struct MonoArray * D.30445;
  struct MonoArray * * D.30446;
  struct MonoArray * D.30447;
  struct MonoType * D.30448;
  short unsigned int D.30449;
  int D.30450;
  int D.30451;
  int D.21693;
  int iftmp.251;
  int D.21689;
  const char[8] * D.30457;
  unsigned char D.30458;
  int D.30459;
  unsigned char D.30460;
  int D.30461;
  const unsigned char * D.30466;
  unsigned char D.30467;
  int D.30468;
  const unsigned char * D.30469;
  unsigned char D.30470;
  int D.30471;
  const unsigned char * D.30476;
  unsigned char D.30477;
  int D.30478;
  const unsigned char * D.30479;
  unsigned char D.30480;
  int D.30481;
  const unsigned char * D.30486;
  unsigned char D.30487;
  int D.30488;
  const unsigned char * D.30489;
  unsigned char D.30490;
  int D.30491;
  const char * D.30493;
  int D.30496;
  int D.21702;
  int iftmp.252;
  int D.21701;
  const char[9] * D.30502;
  unsigned char D.30503;
  int D.30504;
  unsigned char D.30505;
  int D.30506;
  const unsigned char * D.30511;
  unsigned char D.30512;
  int D.30513;
  const unsigned char * D.30514;
  unsigned char D.30515;
  int D.30516;
  const unsigned char * D.30521;
  unsigned char D.30522;
  int D.30523;
  const unsigned char * D.30524;
  unsigned char D.30525;
  int D.30526;
  const unsigned char * D.30531;
  unsigned char D.30532;
  int D.30533;
  const unsigned char * D.30534;
  unsigned char D.30535;
  int D.30536;
  const char * D.30538;
  struct MonoArray * D.30541;
  const char * D.30542;
  struct MonoString * D.30543;
  const char * p.253;
  const char * p.254;
  unsigned int D.30546;
  struct MonoType * D.30547;
  unsigned char D.30548;
  int D.30549;
  struct MonoArray * D.30550;
  char D.30551;
  short unsigned int D.30552;
  short int D.30553;
  unsigned int D.30554;
  int D.30555;
  long long unsigned int D.30556;
  long long int D.30557;
  struct MonoType * D.30558;
  unsigned char D.30559;
  int D.30560;
  struct MonoDomain * domain;
  struct MonoClass * enumc;
  guint j;
  guint nvalues;
  guint crow;
  void * iter;
  struct MonoClassField * field;

  try
    {
      D.30431 = MEM[(struct MonoObject *)type].vtable;
      domain = D.30431->domain;
      D.30432 = type->type;
      enumc = mono_class_from_mono_type (D.30432);
      j = 0;
      mono_class_init_or_throw (enumc);
      D.30433 = &info->utype;
      D.30434 = mono_class_enum_basetype (enumc);
      D.30435 = mono_type_get_object (domain, D.30434);
      mono_gc_wbarrier_generic_store (D.30433, D.30435);
      D.30437 = mono_class_num_fields (enumc);
      if (D.30437 != 0) goto <D.30438>; else goto <D.30439>;
      <D.30438>:
      D.30440 = mono_class_num_fields (enumc);
      D.30441 = D.30440 + -1;
      iftmp.250 = (guint) D.30441;
      goto <D.30442>;
      <D.30439>:
      iftmp.250 = 0;
      <D.30442>:
      nvalues = iftmp.250;
      D.30443 = &info->names;
      D.30444 = mono_defaults.string_class;
      D.30445 = mono_array_new (domain, D.30444, nvalues);
      mono_gc_wbarrier_generic_store (D.30443, D.30445);
      D.30446 = &info->values;
      D.30447 = mono_array_new (domain, enumc, nvalues);
      mono_gc_wbarrier_generic_store (D.30446, D.30447);
      crow = 4294967295;
      iter = 0B;
      goto <D.21684>;
      <D.21720>:
      {
        const char * p;
        int len;
        MonoTypeEnum def_type;

        try
          {
            D.30448 = field->type;
            D.30449 = D.30448->attrs;
            D.30450 = (int) D.30449;
            D.30451 = D.30450 & 16;
            if (D.30451 == 0) goto <D.30452>; else goto <D.30453>;
            <D.30452>:
            // predicted unlikely by continue predictor.
            goto <D.21684>;
            <D.30453>:
            {
              size_t __s1_len;
              size_t __s2_len;

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

                __s2 = mono_field_get_name (field);
                D.30457 = "value__";
                D.30458 = MEM[(const unsigned char *)D.30457];
                D.30459 = (int) D.30458;
                D.30460 = *__s2;
                D.30461 = (int) D.30460;
                __result = D.30459 - D.30461;
                {
                  if (__s1_len != 0) goto <D.30462>; else goto <D.30463>;
                  <D.30462>:
                  if (__result == 0) goto <D.30464>; else goto <D.30465>;
                  <D.30464>:
                  D.30466 = &MEM[(void *)"value__" + 1B];
                  D.30467 = *D.30466;
                  D.30468 = (int) D.30467;
                  D.30469 = __s2 + 1;
                  D.30470 = *D.30469;
                  D.30471 = (int) D.30470;
                  __result = D.30468 - D.30471;
                  if (__s1_len > 1) goto <D.30472>; else goto <D.30473>;
                  <D.30472>:
                  if (__result == 0) goto <D.30474>; else goto <D.30475>;
                  <D.30474>:
                  D.30476 = &MEM[(void *)"value__" + 2B];
                  D.30477 = *D.30476;
                  D.30478 = (int) D.30477;
                  D.30479 = __s2 + 2;
                  D.30480 = *D.30479;
                  D.30481 = (int) D.30480;
                  __result = D.30478 - D.30481;
                  if (__s1_len > 2) goto <D.30482>; else goto <D.30483>;
                  <D.30482>:
                  if (__result == 0) goto <D.30484>; else goto <D.30485>;
                  <D.30484>:
                  D.30486 = &MEM[(void *)"value__" + 3B];
                  D.30487 = *D.30486;
                  D.30488 = (int) D.30487;
                  D.30489 = __s2 + 3;
                  D.30490 = *D.30489;
                  D.30491 = (int) D.30490;
                  __result = D.30488 - D.30491;
                  <D.30485>:
                  <D.30483>:
                  <D.30475>:
                  <D.30473>:
                  <D.30465>:
                  <D.30463>:
                }
                D.21689 = __result;
              }
              iftmp.251 = D.21689;
              goto <D.30492>;
              <D.30456>:
              D.30493 = mono_field_get_name (field);
              iftmp.251 = __builtin_strcmp ("value__", D.30493);
              <D.30492>:
              D.21693 = iftmp.251;
            }
            if (D.21693 == 0) goto <D.30494>; else goto <D.30495>;
            <D.30494>:
            // predicted unlikely by continue predictor.
            goto <D.21684>;
            <D.30495>:
            D.30448 = field->type;
            D.30449 = D.30448->attrs;
            D.30450 = (int) D.30449;
            D.30496 = D.30450 & 1536;
            if (D.30496 != 0) goto <D.30497>; else goto <D.30498>;
            <D.30497>:
            {
              size_t __s1_len;
              size_t __s2_len;

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

                __s2 = mono_field_get_name (field);
                D.30502 = "_Deleted";
                D.30503 = MEM[(const unsigned char *)D.30502];
                D.30504 = (int) D.30503;
                D.30505 = *__s2;
                D.30506 = (int) D.30505;
                __result = D.30504 - D.30506;
                {
                  if (__s2_len != 0) goto <D.30507>; else goto <D.30508>;
                  <D.30507>:
                  if (__result == 0) goto <D.30509>; else goto <D.30510>;
                  <D.30509>:
                  D.30511 = &MEM[(void *)"_Deleted" + 1B];
                  D.30512 = *D.30511;
                  D.30513 = (int) D.30512;
                  D.30514 = __s2 + 1;
                  D.30515 = *D.30514;
                  D.30516 = (int) D.30515;
                  __result = D.30513 - D.30516;
                  if (__s2_len > 1) goto <D.30517>; else goto <D.30518>;
                  <D.30517>:
                  if (__result == 0) goto <D.30519>; else goto <D.30520>;
                  <D.30519>:
                  D.30521 = &MEM[(void *)"_Deleted" + 2B];
                  D.30522 = *D.30521;
                  D.30523 = (int) D.30522;
                  D.30524 = __s2 + 2;
                  D.30525 = *D.30524;
                  D.30526 = (int) D.30525;
                  __result = D.30523 - D.30526;
                  if (__s2_len > 2) goto <D.30527>; else goto <D.30528>;
                  <D.30527>:
                  if (__result == 0) goto <D.30529>; else goto <D.30530>;
                  <D.30529>:
                  D.30531 = &MEM[(void *)"_Deleted" + 3B];
                  D.30532 = *D.30531;
                  D.30533 = (int) D.30532;
                  D.30534 = __s2 + 3;
                  D.30535 = *D.30534;
                  D.30536 = (int) D.30535;
                  __result = D.30533 - D.30536;
                  <D.30530>:
                  <D.30528>:
                  <D.30520>:
                  <D.30518>:
                  <D.30510>:
                  <D.30508>:
                }
                D.21701 = __result;
              }
              iftmp.252 = -D.21701;
              goto <D.30537>;
              <D.30501>:
              D.30538 = mono_field_get_name (field);
              iftmp.252 = __builtin_strcmp (D.30538, "_Deleted");
              <D.30537>:
              D.21702 = iftmp.252;
            }
            if (D.21702 == 0) goto <D.30539>; else goto <D.30540>;
            <D.30539>:
            // predicted unlikely by continue predictor.
            goto <D.21684>;
            <D.30540>:
            <D.30498>:
            {
              void * * __p;

              D.30541 = info->names;
              __p = mono_array_addr_with_size (D.30541, 4, j);
              D.30541 = info->names;
              D.30542 = mono_field_get_name (field);
              D.30543 = mono_string_new (domain, D.30542);
              mono_gc_wbarrier_set_arrayref (D.30541, __p, D.30543);
            }
            p.253 = mono_class_get_field_default_value (field, &def_type);
            p = p.253;
            p.254 = p;
            D.30546 = mono_metadata_decode_blob_size (p.254, &p);
            len = (int) D.30546;
            D.30547 = mono_class_enum_basetype (enumc);
            D.30548 = D.30547->type;
            D.30549 = (int) D.30548;
            switch (D.30549) <default: <D.21718>, case 3: <D.21708>, case 4: <D.21705>, case 5: <D.21704>, case 6: <D.21710>, case 7: <D.21709>, case 8: <D.21713>, case 9: <D.21712>, case 10: <D.21716>, case 11: <D.21715>>
            <D.21704>:
            <D.21705>:
            {
              gchar * __p;

              D.30550 = info->values;
              __p = mono_array_addr_with_size (D.30550, 1, j);
              p.254 = p;
              D.30551 = *p.254;
              *__p = D.30551;
            }
            goto <D.21707>;
            <D.21708>:
            <D.21709>:
            <D.21710>:
            {
              gint16 * __p;

              D.30550 = info->values;
              __p = mono_array_addr_with_size (D.30550, 2, j);
              p.254 = p;
              D.30552 = mono_read16 (p.254);
              D.30553 = (short int) D.30552;
              *__p = D.30553;
            }
            goto <D.21707>;
            <D.21712>:
            <D.21713>:
            {
              gint32 * __p;

              D.30550 = info->values;
              __p = mono_array_addr_with_size (D.30550, 4, j);
              p.254 = p;
              D.30554 = mono_read32 (p.254);
              D.30555 = (int) D.30554;
              *__p = D.30555;
            }
            goto <D.21707>;
            <D.21715>:
            <D.21716>:
            {
              gint64 * __p;

              D.30550 = info->values;
              __p = mono_array_addr_with_size (D.30550, 8, j);
              p.254 = p;
              D.30556 = mono_read64 (p.254);
              D.30557 = (long long int) D.30556;
              *__p = D.30557;
            }
            goto <D.21707>;
            <D.21718>:
            D.30558 = mono_class_enum_basetype (enumc);
            D.30559 = D.30558->type;
            D.30560 = (int) D.30559;
            monoeg_g_log (0B, 4, "Implement type 0x%02x in get_enum_info", D.30560);
            <D.21719>:
            goto <D.21719>;
            <D.21707>:
            j = j + 1;
          }
        finally
          {
            p = {CLOBBER};
            def_type = {CLOBBER};
          }
      }
      <D.21684>:
      field = mono_class_get_fields (enumc, &iter);
      if (field != 0B) goto <D.21720>; else goto <D.21721>;
      <D.21721>:
    }
  finally
    {
      iter = {CLOBBER};
    }
}


custom_attrs_defined_internal (struct MonoObject * obj, struct MonoReflectionType * attr_type)
{
  struct MonoType * D.30563;
  MonoBoolean D.30566;
  int D.30567;
  struct MonoClass * attr_class;
  struct MonoCustomAttrInfo * cinfo;
  gboolean found;

  D.30563 = attr_type->type;
  attr_class = mono_class_from_mono_type (D.30563);
  mono_class_init_or_throw (attr_class);
  cinfo = mono_reflection_get_custom_attrs_info (obj);
  if (cinfo == 0B) goto <D.30564>; else goto <D.30565>;
  <D.30564>:
  D.30566 = 0;
  return D.30566;
  <D.30565>:
  found = mono_custom_attrs_has_attr (cinfo, attr_class);
  D.30567 = cinfo->cached;
  if (D.30567 == 0) goto <D.30568>; else goto <D.30569>;
  <D.30568>:
  mono_custom_attrs_free (cinfo);
  <D.30569>:
  D.30566 = (MonoBoolean) found;
  return D.30566;
}


custom_attrs_get_by_type (struct MonoObject * obj, struct MonoReflectionType * attr_type)
{
  struct MonoClass * iftmp.255;
  struct MonoType * D.30574;
  int D.30578;
  struct MonoLoaderError * D.30581;
  struct MonoLoaderError * D.30584;
  struct MonoException * D.30585;
  struct MonoArray * D.30586;
  struct MonoClass * attr_class;
  struct MonoArray * res;
  struct MonoError error;

  try
    {
      if (attr_type != 0B) goto <D.30572>; else goto <D.30573>;
      <D.30572>:
      D.30574 = attr_type->type;
      iftmp.255 = mono_class_from_mono_type (D.30574);
      goto <D.30575>;
      <D.30573>:
      iftmp.255 = 0B;
      <D.30575>:
      attr_class = iftmp.255;
      if (attr_class != 0B) goto <D.30576>; else goto <D.30577>;
      <D.30576>:
      mono_class_init_or_throw (attr_class);
      <D.30577>:
      res = mono_reflection_get_custom_attrs_by_type (obj, attr_class, &error);
      D.30578 = mono_error_ok (&error);
      if (D.30578 == 0) goto <D.30579>; else goto <D.30580>;
      <D.30579>:
      mono_error_raise_exception (&error);
      <D.30580>:
      D.30581 = mono_loader_get_last_error ();
      if (D.30581 != 0B) goto <D.30582>; else goto <D.30583>;
      <D.30582>:
      D.30584 = mono_loader_get_last_error ();
      D.30585 = mono_loader_error_prepare_exception (D.30584);
      mono_raise_exception (D.30585);
      monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "icall.c", 7569);
      D.30586 = 0B;
      return D.30586;
      <D.30583>:
      D.30586 = res;
      return D.30586;
    }
  finally
    {
      error = {CLOBBER};
    }
}


ves_icall_System_IO_get_temp_path ()
{
  struct MonoString * D.30589;
  struct MonoDomain * D.30590;
  const gchar * D.30591;

  D.30590 = mono_domain_get ();
  D.30591 = monoeg_g_get_tmp_dir ();
  D.30589 = mono_string_new (D.30590, D.30591);
  return D.30589;
}


ves_icall_System_IO_DriveInfo_GetDriveType (struct MonoString * root_path_name)
{
  guint32 D.30593;
  mono_unichar2 * D.30594;

  D.30594 = mono_string_chars (root_path_name);
  D.30593 = GetDriveType (D.30594);
  return D.30593;
}


ves_icall_System_IO_DriveInfo_GetDriveFormat (struct MonoString * path)
{
  mono_unichar2 * D.30596;
  int D.30597;
  struct MonoString * D.30600;
  gunichar2 volume_name[261];

  try
    {
      D.30596 = mono_string_chars (path);
      D.30597 = GetVolumeInformation (D.30596, 0B, 0, 0B, 0B, 0B, &volume_name, 261);
      if (D.30597 == 0) goto <D.30598>; else goto <D.30599>;
      <D.30598>:
      D.30600 = 0B;
      return D.30600;
      <D.30599>:
      D.30600 = mono_string_from_utf16 (&volume_name);
      return D.30600;
    }
  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.30603;
  long long unsigned int D.30606;
  long long unsigned int D.30607;
  long long unsigned int D.30608;
  unsigned int D.30610;
  int D.30611;
  MonoBoolean D.30612;
  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.30603 = mono_string_chars (path_name);
      result = GetDiskFreeSpaceEx (D.30603, &wapi_free_bytes_avail, &wapi_total_number_of_bytes, &wapi_total_number_of_free_bytes);
      if (result != 0) goto <D.30604>; else goto <D.30605>;
      <D.30604>:
      D.30606 = wapi_free_bytes_avail.QuadPart;
      *free_bytes_avail = D.30606;
      D.30607 = wapi_total_number_of_bytes.QuadPart;
      *total_number_of_bytes = D.30607;
      D.30608 = wapi_total_number_of_free_bytes.QuadPart;
      *total_number_of_free_bytes = D.30608;
      goto <D.30609>;
      <D.30605>:
      *free_bytes_avail = 0;
      *total_number_of_bytes = 0;
      *total_number_of_free_bytes = 0;
      D.30610 = GetLastError ();
      D.30611 = (int) D.30610;
      *error = D.30611;
      <D.30609>:
      D.30612 = (MonoBoolean) result;
      return D.30612;
    }
  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.30615;
  struct MonoDomain * D.30616;
  const gchar * D.30617;

  D.30616 = mono_domain_get ();
  D.30617 = monoeg_g_get_home_dir ();
  D.30615 = mono_string_new (D.30616, D.30617);
  return D.30615;
}


ves_icall_System_Environment_GetGacPath ()
{
  struct MonoString * D.30619;
  struct MonoDomain * D.30620;
  const char * D.30621;

  D.30620 = mono_domain_get ();
  D.30621 = mono_assembly_getrootdir ();
  D.30619 = mono_string_new (D.30620, D.30621);
  return D.30619;
}


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

  if (name == 0B) goto <D.30623>; else goto <D.30624>;
  <D.30623>:
  D.30625 = 0B;
  return D.30625;
  <D.30624>:
  utf8_name = mono_string_to_utf8 (name);
  value = monoeg_g_getenv (utf8_name);
  monoeg_g_free (utf8_name);
  if (value == 0B) goto <D.30626>; else goto <D.30627>;
  <D.30626>:
  D.30625 = 0B;
  return D.30625;
  <D.30627>:
  D.30628 = mono_domain_get ();
  D.30625 = mono_string_new (D.30628, value);
  return D.30625;
}


ves_icall_System_Environment_BroadcastSettingChange ()
{

}


ves_icall_System_Environment_get_Platform ()
{
  int D.30630;

  D.30630 = 4;
  return D.30630;
}


ves_icall_System_Environment_get_MachineName ()
{
  int D.30632;
  struct MonoDomain * D.30635;
  struct MonoString * D.30637;
  gchar buf[256];
  struct MonoString * result;

  try
    {
      D.30632 = gethostname (&buf, 256);
      if (D.30632 == 0) goto <D.30633>; else goto <D.30634>;
      <D.30633>:
      D.30635 = mono_domain_get ();
      result = mono_string_new (D.30635, &buf);
      goto <D.30636>;
      <D.30634>:
      result = 0B;
      <D.30636>:
      D.30637 = result;
      return D.30637;
    }
  finally
    {
      buf = {CLOBBER};
    }
}


gethostname (char * __buf, size_t __buflen)
{
  unsigned int D.30640;
  int D.30643;
  int D.30646;
  unsigned int D.30647;
  unsigned int D.30648;
  unsigned int D.30651;

  D.30640 = __builtin_object_size (__buf, 1);
  if (D.30640 != 4294967295) goto <D.30641>; else goto <D.30642>;
  <D.30641>:
  D.30643 = __builtin_constant_p (__buflen);
  if (D.30643 == 0) goto <D.30644>; else goto <D.30645>;
  <D.30644>:
  D.30647 = __builtin_object_size (__buf, 1);
  D.30646 = __gethostname_chk (__buf, __buflen, D.30647);
  return D.30646;
  <D.30645>:
  D.30648 = __builtin_object_size (__buf, 1);
  if (D.30648 < __buflen) goto <D.30649>; else goto <D.30650>;
  <D.30649>:
  D.30651 = __builtin_object_size (__buf, 1);
  D.30646 = __gethostname_chk_warn (__buf, __buflen, D.30651);
  return D.30646;
  <D.30650>:
  <D.30642>:
  D.30646 = __gethostname_alias (__buf, __buflen);
  return D.30646;
}


ves_icall_System_Environment_get_HasShutdownStarted ()
{
  int D.30653;
  MonoBoolean D.30656;
  struct MonoDomain * D.30657;
  int D.30658;

  D.30653 = mono_runtime_is_shutting_down ();
  if (D.30653 != 0) goto <D.30654>; else goto <D.30655>;
  <D.30654>:
  D.30656 = 1;
  return D.30656;
  <D.30655>:
  D.30657 = mono_domain_get ();
  D.30658 = mono_domain_is_unloading (D.30657);
  if (D.30658 != 0) goto <D.30659>; else goto <D.30660>;
  <D.30659>:
  D.30656 = 1;
  return D.30656;
  <D.30660>:
  D.30656 = 0;
  return D.30656;
}


ves_icall_System_Environment_InternalSetEnvironmentVariable (struct MonoString * name, struct MonoString * value)
{
  int D.30665;
  mono_unichar2 * D.30667;
  short unsigned int D.30668;
  int D.30669;
  struct MonoError error;
  gchar * utf8_name;
  gchar * utf8_value;

  try
    {
      utf8_name = mono_string_to_utf8 (name);
      if (value == 0B) goto <D.30662>; else goto <D.30664>;
      <D.30664>:
      D.30665 = mono_string_length (value);
      if (D.30665 == 0) goto <D.30662>; else goto <D.30666>;
      <D.30666>:
      D.30667 = mono_string_chars (value);
      D.30668 = *D.30667;
      if (D.30668 == 0) goto <D.30662>; else goto <D.30663>;
      <D.30662>:
      monoeg_g_unsetenv (utf8_name);
      monoeg_g_free (utf8_name);
      return;
      <D.30663>:
      utf8_value = mono_string_to_utf8_checked (value, &error);
      D.30669 = mono_error_ok (&error);
      if (D.30669 == 0) goto <D.30670>; else goto <D.30671>;
      <D.30670>:
      monoeg_g_free (utf8_name);
      mono_error_raise_exception (&error);
      <D.30671>:
      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.30675;
  struct MonoDomain * D.30676;

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


ves_icall_System_Environment_get_NewLine ()
{
  struct MonoString * D.30678;
  struct MonoDomain * D.30679;

  D.30679 = mono_domain_get ();
  D.30678 = mono_string_new (D.30679, "\n");
  return D.30678;
}


ves_icall_System_Environment_GetLogicalDrives ()
{
  int D.30681;
  unsigned int D.30686;
  unsigned int D.30687;
  gunichar2 * dname.256;
  short unsigned int D.30689;
  short unsigned int D.30690;
  struct MonoClass * D.30691;
  unsigned int ndrives.257;
  short unsigned int D.30693;
  int ndrives.258;
  unsigned int ndrives.259;
  gunichar2 * dname.260;
  short unsigned int D.30697;
  struct MonoArray * D.30700;
  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.22876>;
      <D.22875>:
      D.30681 = GetLogicalDriveStrings (initial_size, ptr);
      size = (guint) D.30681;
      if (size > initial_size) goto <D.30682>; else goto <D.30683>;
      <D.30682>:
      if (&buf != ptr) goto <D.30684>; else goto <D.30685>;
      <D.30684>:
      monoeg_g_free (ptr);
      <D.30685>:
      D.30686 = size + 1;
      D.30687 = D.30686 * 2;
      ptr = monoeg_malloc0 (D.30687);
      initial_size = size;
      size = size + 1;
      <D.30683>:
      <D.22876>:
      if (size > initial_size) goto <D.22875>; else goto <D.22877>;
      <D.22877>:
      dname = ptr;
      ndrives = 0;
      <D.22881>:
      goto <D.22879>;
      <D.22878>:
      <D.22879>:
      dname.256 = dname;
      dname = dname.256 + 2;
      D.30689 = *dname.256;
      if (D.30689 != 0) goto <D.22878>; else goto <D.22880>;
      <D.22880>:
      ndrives = ndrives + 1;
      D.30690 = *dname;
      if (D.30690 != 0) goto <D.22881>; else goto <D.22882>;
      <D.22882>:
      dname = ptr;
      D.30691 = mono_defaults.string_class;
      ndrives.257 = (unsigned int) ndrives;
      result = mono_array_new (domain, D.30691, ndrives.257);
      ndrives = 0;
      <D.22890>:
      len = 0;
      u16 = dname;
      goto <D.22884>;
      <D.22883>:
      u16 = u16 + 2;
      len = len + 1;
      <D.22884>:
      D.30693 = *u16;
      if (D.30693 != 0) goto <D.22883>; else goto <D.22885>;
      <D.22885>:
      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.22888>;
      <D.22887>:
      <D.22888>:
      dname.260 = dname;
      dname = dname.260 + 2;
      D.30697 = *dname.260;
      if (D.30697 != 0) goto <D.22887>; else goto <D.22889>;
      <D.22889>:
      D.30690 = *dname;
      if (D.30690 != 0) goto <D.22890>; else goto <D.22891>;
      <D.22891>:
      if (&buf != ptr) goto <D.30698>; else goto <D.30699>;
      <D.30698>:
      monoeg_g_free (ptr);
      <D.30699>:
      D.30700 = result;
      return D.30700;
    }
  finally
    {
      buf = {CLOBBER};
    }
}


ves_icall_System_Environment_GetEnvironmentVariableNames ()
{
  gchar * D.30703;
  struct MonoClass * D.30704;
  unsigned int n.261;
  gchar * D.30706;
  struct MonoArray * D.30709;
  struct MonoArray * names;
  struct MonoDomain * domain;
  struct MonoString * str;
  gchar * * e;
  gchar * * parts;
  int n;

  n = 0;
  e = environ;
  goto <D.22839>;
  <D.22838>:
  n = n + 1;
  e = e + 4;
  <D.22839>:
  D.30703 = *e;
  if (D.30703 != 0B) goto <D.22838>; else goto <D.22840>;
  <D.22840>:
  domain = mono_domain_get ();
  D.30704 = mono_defaults.string_class;
  n.261 = (unsigned int) n;
  names = mono_array_new (domain, D.30704, n.261);
  n = 0;
  e = environ;
  goto <D.22843>;
  <D.22842>:
  D.30703 = *e;
  parts = monoeg_g_strsplit (D.30703, "=", 2);
  D.30706 = *parts;
  if (D.30706 != 0B) goto <D.30707>; else goto <D.30708>;
  <D.30707>:
  D.30706 = *parts;
  str = mono_string_new (domain, D.30706);
  {
    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.30708>:
  monoeg_g_strfreev (parts);
  n = n + 1;
  e = e + 4;
  <D.22843>:
  D.30703 = *e;
  if (D.30703 != 0B) goto <D.22842>; else goto <D.22844>;
  <D.22844>:
  D.30709 = names;
  return D.30709;
}


ves_icall_System_Environment_Exit (int result)
{
  int D.30711;

  mono_environment_exitcode_set (result);
  D.30711 = mono_runtime_try_shutdown ();
  if (D.30711 == 0) goto <D.30712>; else goto <D.30713>;
  <D.30712>:
  mono_thread_exit ();
  <D.30713>:
  mono_thread_suspend_all_other_threads ();
  mono_runtime_quit ();
  exit (result);
}


ves_icall_System_Enum_get_value (struct MonoObject * this)
{
  struct MonoObject * D.30716;
  struct MonoVTable * D.30717;
  struct MonoClass * D.30718;
  unsigned int D.30719;
  unsigned int D.30720;
  _Bool D.30721;
  long int D.30722;
  long int D.30723;
  struct MonoType * D.30726;
  struct MonoDomain * D.30727;
  unsigned int size.262;
  struct MonoObject * res;
  struct MonoClass * enumc;
  void * dst;
  void * src;
  int size;

  if (this == 0B) goto <D.30714>; else goto <D.30715>;
  <D.30714>:
  D.30716 = 0B;
  return D.30716;
  <D.30715>:
  D.30717 = this->vtable;
  D.30718 = D.30717->klass;
  D.30719 = BIT_FIELD_REF <*D.30718, 32, 160>;
  D.30720 = D.30719 & 16;
  D.30721 = D.30720 == 0;
  D.30722 = (long int) D.30721;
  D.30723 = __builtin_expect (D.30722, 0);
  if (D.30723 != 0) goto <D.30724>; else goto <D.30725>;
  <D.30724>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "icall.c", 3088, "this->vtable->klass->enumtype");
  <D.30725>:
  D.30717 = this->vtable;
  D.30718 = D.30717->klass;
  D.30726 = mono_class_enum_basetype (D.30718);
  enumc = mono_class_from_mono_type (D.30726);
  D.30717 = this->vtable;
  D.30727 = D.30717->domain;
  res = mono_object_new (D.30727, 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.30716 = res;
  return D.30716;
}


ves_icall_System_Enum_get_underlying_type (struct MonoReflectionType * type)
{
  struct MonoType * D.30730;
  struct MonoException * D.30733;
  struct MonoReflectionType * D.30734;
  struct MonoVTable * D.30735;
  struct MonoDomain * D.30736;
  struct MonoType * etype;
  struct MonoClass * klass;

  D.30730 = type->type;
  klass = mono_class_from_mono_type (D.30730);
  mono_class_init_or_throw (klass);
  etype = mono_class_enum_basetype (klass);
  if (etype == 0B) goto <D.30731>; else goto <D.30732>;
  <D.30731>:
  D.30733 = mono_get_exception_argument ("Type must be a type provided by the runtime.", "enumType");
  mono_raise_exception (D.30733);
  <D.30732>:
  D.30735 = MEM[(struct MonoObject *)type].vtable;
  D.30736 = D.30735->domain;
  D.30734 = mono_type_get_object (D.30736, etype);
  return D.30734;
}


ves_icall_System_Enum_get_hashcode (struct MonoObject * this)
{
  struct MonoVTable * D.30738;
  struct MonoClass * D.30739;
  _Bool D.30740;
  long int D.30741;
  long int D.30742;
  unsigned char D.30745;
  int D.30746;
  int D.30747;
  signed char D.30748;
  unsigned char D.30749;
  short unsigned int D.30750;
  short int D.30751;
  unsigned int D.30752;
  int D.30753;
  long long int D.30754;
  int D.30755;
  void * data;
  struct MonoType * basetype;

  data = this + 8;
  D.30738 = this->vtable;
  D.30739 = D.30738->klass;
  basetype = mono_class_enum_basetype (D.30739);
  D.30740 = basetype == 0B;
  D.30741 = (long int) D.30740;
  D.30742 = __builtin_expect (D.30741, 0);
  if (D.30742 != 0) goto <D.30743>; else goto <D.30744>;
  <D.30743>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "icall.c", 3175, "basetype");
  <D.30744>:
  D.30745 = basetype->type;
  D.30746 = (int) D.30745;
  switch (D.30746) <default: <D.21668>, case 3: <D.21660>, case 4: <D.21658>, case 5: <D.21659>, case 6: <D.21662>, case 7: <D.21661>, case 8: <D.21664>, case 9: <D.21663>, case 10: <D.21666>, case 11: <D.21665>>
  <D.21658>:
  D.30748 = MEM[(gint8 *)data];
  D.30747 = (int) D.30748;
  return D.30747;
  <D.21659>:
  D.30749 = MEM[(guint8 *)data];
  D.30747 = (int) D.30749;
  return D.30747;
  <D.21660>:
  <D.21661>:
  D.30750 = MEM[(guint16 *)data];
  D.30747 = (int) D.30750;
  return D.30747;
  <D.21662>:
  D.30751 = MEM[(gint16 *)data];
  D.30747 = (int) D.30751;
  return D.30747;
  <D.21663>:
  D.30752 = MEM[(guint32 *)data];
  D.30747 = (int) D.30752;
  return D.30747;
  <D.21664>:
  D.30747 = MEM[(gint32 *)data];
  return D.30747;
  <D.21665>:
  <D.21666>:
  {
    gint64 value;

    value = MEM[(gint64 *)data];
    D.30753 = (int) value;
    D.30754 = value >> 32;
    D.30755 = (int) D.30754;
    D.30747 = D.30753 ^ D.30755;
    return D.30747;
  }
  <D.21668>:
  D.30745 = basetype->type;
  D.30746 = (int) D.30745;
  monoeg_g_log (0B, 4, "Implement type 0x%02x in get_hashcode", D.30746);
  <D.21669>:
  goto <D.21669>;
  D.30747 = 0;
  return D.30747;
}


ves_icall_System_Enum_compare_value_to (struct MonoObject * this, struct MonoObject * other)
{
  struct MonoVTable * D.30757;
  struct MonoClass * D.30758;
  _Bool D.30759;
  long int D.30760;
  long int D.30761;
  unsigned char D.30764;
  int D.30765;
  int D.30768;
  int iftmp.263;
  int iftmp.264;
  int D.30781;
  int D.30782;
  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.30757 = this->vtable;
  D.30758 = D.30757->klass;
  basetype = mono_class_enum_basetype (D.30758);
  D.30759 = basetype == 0B;
  D.30760 = (long int) D.30759;
  D.30761 = __builtin_expect (D.30760, 0);
  if (D.30761 != 0) goto <D.30762>; else goto <D.30763>;
  <D.30762>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "icall.c", 3126, "basetype");
  <D.30763>:
  D.30764 = basetype->type;
  D.30765 = (int) D.30764;
  switch (D.30765) <default: <D.21651>, case 3: <D.21632>, case 4: <D.21629>, case 5: <D.21626>, case 6: <D.21636>, case 7: <D.21633>, case 8: <D.21642>, case 9: <D.21639>, case 10: <D.21648>, case 11: <D.21645>>
  <D.21626>:
  {
    guint8 me;
    guint8 other;

    me = MEM[(guint8 *)tdata];
    other = MEM[(guint8 *)odata];
    if (me == other) goto <D.30766>; else goto <D.30767>;
    <D.30766>:
    D.30768 = 0;
    return D.30768;
    <D.30767>:
    if (me > other) goto <D.30770>; else goto <D.30771>;
    <D.30770>:
    iftmp.263 = 1;
    goto <D.30772>;
    <D.30771>:
    iftmp.263 = -1;
    <D.30772>:
    D.30768 = iftmp.263;
    return D.30768;
  }
  <D.21629>:
  {
    gint8 me;
    gint8 other;

    me = MEM[(gint8 *)tdata];
    other = MEM[(gint8 *)odata];
    if (me == other) goto <D.30773>; else goto <D.30774>;
    <D.30773>:
    D.30768 = 0;
    return D.30768;
    <D.30774>:
    if (me > other) goto <D.30776>; else goto <D.30777>;
    <D.30776>:
    iftmp.264 = 1;
    goto <D.30778>;
    <D.30777>:
    iftmp.264 = -1;
    <D.30778>:
    D.30768 = iftmp.264;
    return D.30768;
  }
  <D.21632>:
  <D.21633>:
  {
    guint16 me;
    guint16 other;

    me = MEM[(guint16 *)tdata];
    other = MEM[(guint16 *)odata];
    if (me == other) goto <D.30779>; else goto <D.30780>;
    <D.30779>:
    D.30768 = 0;
    return D.30768;
    <D.30780>:
    D.30781 = (int) me;
    D.30782 = (int) other;
    D.30768 = D.30781 - D.30782;
    return D.30768;
  }
  <D.21636>:
  {
    gint16 me;
    gint16 other;

    me = MEM[(gint16 *)tdata];
    other = MEM[(gint16 *)odata];
    if (me == other) goto <D.30783>; else goto <D.30784>;
    <D.30783>:
    D.30768 = 0;
    return D.30768;
    <D.30784>:
    if (me > other) goto <D.30786>; else goto <D.30787>;
    <D.30786>:
    iftmp.265 = 1;
    goto <D.30788>;
    <D.30787>:
    iftmp.265 = -1;
    <D.30788>:
    D.30768 = iftmp.265;
    return D.30768;
  }
  <D.21639>:
  {
    guint32 me;
    guint32 other;

    me = MEM[(guint32 *)tdata];
    other = MEM[(guint32 *)odata];
    if (me == other) goto <D.30789>; else goto <D.30790>;
    <D.30789>:
    D.30768 = 0;
    return D.30768;
    <D.30790>:
    if (me > other) goto <D.30792>; else goto <D.30793>;
    <D.30792>:
    iftmp.266 = 1;
    goto <D.30794>;
    <D.30793>:
    iftmp.266 = -1;
    <D.30794>:
    D.30768 = iftmp.266;
    return D.30768;
  }
  <D.21642>:
  {
    gint32 me;
    gint32 other;

    me = MEM[(gint32 *)tdata];
    other = MEM[(gint32 *)odata];
    if (me == other) goto <D.30795>; else goto <D.30796>;
    <D.30795>:
    D.30768 = 0;
    return D.30768;
    <D.30796>:
    if (me > other) goto <D.30798>; else goto <D.30799>;
    <D.30798>:
    iftmp.267 = 1;
    goto <D.30800>;
    <D.30799>:
    iftmp.267 = -1;
    <D.30800>:
    D.30768 = iftmp.267;
    return D.30768;
  }
  <D.21645>:
  {
    guint64 me;
    guint64 other;

    me = MEM[(guint64 *)tdata];
    other = MEM[(guint64 *)odata];
    if (me == other) goto <D.30801>; else goto <D.30802>;
    <D.30801>:
    D.30768 = 0;
    return D.30768;
    <D.30802>:
    if (me > other) goto <D.30804>; else goto <D.30805>;
    <D.30804>:
    iftmp.268 = 1;
    goto <D.30806>;
    <D.30805>:
    iftmp.268 = -1;
    <D.30806>:
    D.30768 = iftmp.268;
    return D.30768;
  }
  <D.21648>:
  {
    gint64 me;
    gint64 other;

    me = MEM[(gint64 *)tdata];
    other = MEM[(gint64 *)odata];
    if (me == other) goto <D.30807>; else goto <D.30808>;
    <D.30807>:
    D.30768 = 0;
    return D.30768;
    <D.30808>:
    if (me > other) goto <D.30810>; else goto <D.30811>;
    <D.30810>:
    iftmp.269 = 1;
    goto <D.30812>;
    <D.30811>:
    iftmp.269 = -1;
    <D.30812>:
    D.30768 = iftmp.269;
    return D.30768;
  }
  <D.21651>:
  D.30764 = basetype->type;
  D.30765 = (int) D.30764;
  monoeg_g_log (0B, 4, "Implement type 0x%02x in get_hashcode", D.30765);
  <D.21652>:
  goto <D.21652>;
  D.30768 = 0;
  return D.30768;
}


ves_icall_System_Enum_ToObject (struct MonoReflectionType * enumType, struct MonoObject * value)
{
  _Bool D.30814;
  long int D.30815;
  long int D.30816;
  _Bool D.30821;
  long int D.30822;
  long int D.30823;
  struct MonoVTable * D.30828;
  struct MonoType * D.30829;
  struct MonoVTable * D.30830;
  unsigned int D.30831;
  unsigned int D.30832;
  struct MonoException * D.30835;
  unsigned int D.30836;
  unsigned int D.30837;
  unsigned char D.30840;
  unsigned char D.30841;
  struct MonoException * D.30844;
  struct MonoException * D.30847;
  char * D.30848;
  int iftmp.270;
  struct MonoType * D.30852;
  unsigned char D.30853;
  char * D.30855;
  unsigned char D.30856;
  int D.30857;
  struct MonoObject * D.30858;
  struct MonoDomain * domain;
  struct MonoClass * enumc;
  struct MonoClass * objc;
  struct MonoObject * res;
  struct MonoType * etype;
  guint64 val;

  D.30814 = enumType == 0B;
  D.30815 = (long int) D.30814;
  D.30816 = __builtin_expect (D.30815, 0);
  if (D.30816 != 0) goto <D.30817>; else goto <D.30818>;
  <D.30817>:
  {
    struct MonoException * ex;

    if (enumType != 0B) goto <D.30819>; else goto <D.30820>;
    <D.30819>:
    <D.30820>:
    ex = mono_get_exception_argument_null ("enumType");
    mono_raise_exception (ex);
  }
  <D.30818>:
  D.30821 = value == 0B;
  D.30822 = (long int) D.30821;
  D.30823 = __builtin_expect (D.30822, 0);
  if (D.30823 != 0) goto <D.30824>; else goto <D.30825>;
  <D.30824>:
  {
    struct MonoException * ex;

    if (value != 0B) goto <D.30826>; else goto <D.30827>;
    <D.30826>:
    <D.30827>:
    ex = mono_get_exception_argument_null ("value");
    mono_raise_exception (ex);
  }
  <D.30825>:
  D.30828 = MEM[(struct MonoObject *)enumType].vtable;
  domain = D.30828->domain;
  D.30829 = enumType->type;
  enumc = mono_class_from_mono_type (D.30829);
  mono_class_init_or_throw (enumc);
  D.30830 = value->vtable;
  objc = D.30830->klass;
  D.30831 = BIT_FIELD_REF <*enumc, 32, 160>;
  D.30832 = D.30831 & 16;
  if (D.30832 == 0) goto <D.30833>; else goto <D.30834>;
  <D.30833>:
  D.30835 = mono_get_exception_argument ("enumType", "Type provided must be an Enum.");
  mono_raise_exception (D.30835);
  <D.30834>:
  D.30836 = BIT_FIELD_REF <*objc, 32, 160>;
  D.30837 = D.30836 & 16;
  if (D.30837 == 0) goto <D.30838>; else goto <D.30839>;
  <D.30838>:
  D.30840 = objc->byval_arg.type;
  D.30841 = D.30840 + 252;
  if (D.30841 > 7) goto <D.30842>; else goto <D.30843>;
  <D.30842>:
  D.30844 = 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.30844);
  <D.30843>:
  <D.30839>:
  etype = mono_class_enum_basetype (enumc);
  if (etype == 0B) goto <D.30845>; else goto <D.30846>;
  <D.30845>:
  D.30847 = mono_get_exception_argument ("Type must be a type provided by the runtime.", "enumType");
  mono_raise_exception (D.30847);
  <D.30846>:
  res = mono_object_new (domain, enumc);
  D.30848 = value + 8;
  D.30836 = BIT_FIELD_REF <*objc, 32, 160>;
  D.30837 = D.30836 & 16;
  if (D.30837 != 0) goto <D.30850>; else goto <D.30851>;
  <D.30850>:
  D.30852 = mono_class_enum_basetype (objc);
  D.30853 = D.30852->type;
  iftmp.270 = (int) D.30853;
  goto <D.30854>;
  <D.30851>:
  D.30840 = objc->byval_arg.type;
  iftmp.270 = (int) D.30840;
  <D.30854>:
  val = read_enum_value (D.30848, iftmp.270);
  D.30855 = res + 8;
  D.30856 = etype->type;
  D.30857 = (int) D.30856;
  write_enum_value (D.30855, D.30857, val);
  D.30858 = res;
  return D.30858;
}


read_enum_value (char * mem, int type)
{
  guint64 D.30860;
  unsigned char D.30861;
  signed char D.30862;
  short unsigned int D.30863;
  short int D.30864;
  unsigned int D.30865;
  int D.30866;
  long long int D.30867;

  switch (type) <default: <D.21574>, case 4: <D.21567>, case 5: <D.21566>, case 6: <D.21569>, case 7: <D.21568>, case 8: <D.21571>, case 9: <D.21570>, case 10: <D.21573>, case 11: <D.21572>>
  <D.21566>:
  D.30861 = MEM[(guint8 *)mem];
  D.30860 = (guint64) D.30861;
  return D.30860;
  <D.21567>:
  D.30862 = MEM[(gint8 *)mem];
  D.30860 = (guint64) D.30862;
  return D.30860;
  <D.21568>:
  D.30863 = MEM[(guint16 *)mem];
  D.30860 = (guint64) D.30863;
  return D.30860;
  <D.21569>:
  D.30864 = MEM[(gint16 *)mem];
  D.30860 = (guint64) D.30864;
  return D.30860;
  <D.21570>:
  D.30865 = MEM[(guint32 *)mem];
  D.30860 = (guint64) D.30865;
  return D.30860;
  <D.21571>:
  D.30866 = MEM[(gint32 *)mem];
  D.30860 = (guint64) D.30866;
  return D.30860;
  <D.21572>:
  D.30860 = MEM[(guint64 *)mem];
  return D.30860;
  <D.21573>:
  D.30867 = MEM[(gint64 *)mem];
  D.30860 = (guint64) D.30867;
  return D.30860;
  <D.21574>:
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "icall.c", 2997);
  D.30860 = 0;
  return D.30860;
}


write_enum_value (char * mem, int type, guint64 value)
{
  unsigned char D.30869;
  short unsigned int D.30870;
  unsigned int D.30871;

  switch (type) <default: <D.21593>, case 4: <D.21581>, case 5: <D.21580>, case 6: <D.21585>, case 7: <D.21584>, case 8: <D.21588>, case 9: <D.21587>, case 10: <D.21591>, case 11: <D.21590>>
  <D.21580>:
  <D.21581>:
  {
    guint8 * p;

    p = mem;
    D.30869 = (unsigned char) value;
    *p = D.30869;
    goto <D.21583>;
  }
  <D.21584>:
  <D.21585>:
  {
    guint16 * p;

    p = mem;
    D.30870 = (short unsigned int) value;
    *p = D.30870;
    goto <D.21583>;
  }
  <D.21587>:
  <D.21588>:
  {
    guint32 * p;

    p = mem;
    D.30871 = (unsigned int) value;
    *p = D.30871;
    goto <D.21583>;
  }
  <D.21590>:
  <D.21591>:
  {
    guint64 * p;

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


mono_double_ParseImpl (char * ptr, double * result)
{
  char D.30873;
  _Bool D.30878;
  long int D.30879;
  long int D.30880;
  double D.30883;
  _Bool D.30886;
  long int D.30887;
  long int D.30888;
  gchar * endptr.271;
  char D.30896;
  gboolean D.30897;
  gchar * endptr;

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

        ret = pthread_mutex_lock (&mono_strtod_mutex.mutex);
        if (ret != 0) goto <D.30876>; else goto <D.30877>;
        <D.30876>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
        <D.30877>:
        D.30878 = ret != 0;
        D.30879 = (long int) D.30878;
        D.30880 = __builtin_expect (D.30879, 0);
        if (D.30880 != 0) goto <D.30881>; else goto <D.30882>;
        <D.30881>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "icall.c", 133, "ret == 0");
        <D.30882>:
      }
      D.30883 = mono_strtod (ptr, &endptr);
      *result = D.30883;
      {
        int ret;

        ret = pthread_mutex_unlock (&mono_strtod_mutex.mutex);
        if (ret != 0) goto <D.30884>; else goto <D.30885>;
        <D.30884>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
        <D.30885>:
        D.30886 = ret != 0;
        D.30887 = (long int) D.30886;
        D.30888 = __builtin_expect (D.30887, 0);
        if (D.30888 != 0) goto <D.30889>; else goto <D.30890>;
        <D.30889>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "icall.c", 135, "ret == 0");
        <D.30890>:
      }
      <D.30875>:
      D.30873 = *ptr;
      if (D.30873 == 0) goto <D.30891>; else goto <D.30893>;
      <D.30893>:
      endptr.271 = endptr;
      if (endptr.271 != 0B) goto <D.30895>; else goto <D.30892>;
      <D.30895>:
      endptr.271 = endptr;
      D.30896 = *endptr.271;
      if (D.30896 != 0) goto <D.30891>; else goto <D.30892>;
      <D.30891>:
      D.30897 = 0;
      return D.30897;
      <D.30892>:
      D.30897 = 1;
      return D.30897;
    }
  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.30900;
  void (*<T26f4>) (int, struct MonoString *, struct MonoString *) D.30901;
  struct MonoRuntimeCallbacks * D.30904;
  void (*<T26f4>) (int, struct MonoString *, struct MonoString *) D.30905;

  D.30900 = mono_get_runtime_callbacks ();
  D.30901 = D.30900->debug_log;
  if (D.30901 != 0B) goto <D.30902>; else goto <D.30903>;
  <D.30902>:
  D.30904 = mono_get_runtime_callbacks ();
  D.30905 = D.30904->debug_log;
  D.30905 (level, category, message);
  <D.30903>:
}


ves_icall_System_Diagnostics_Debugger_IsLogging ()
{
  struct MonoRuntimeCallbacks * D.30906;
  gboolean (*<T26f8>) (void) D.30907;
  MonoBoolean D.30910;
  struct MonoRuntimeCallbacks * D.30911;
  gboolean (*<T26f8>) (void) D.30912;
  int D.30913;

  D.30906 = mono_get_runtime_callbacks ();
  D.30907 = D.30906->debug_log_is_enabled;
  if (D.30907 != 0B) goto <D.30908>; else goto <D.30909>;
  <D.30908>:
  D.30911 = mono_get_runtime_callbacks ();
  D.30912 = D.30911->debug_log_is_enabled;
  D.30913 = D.30912 ();
  D.30910 = (MonoBoolean) D.30913;
  return D.30910;
  <D.30909>:
  D.30910 = 0;
  return D.30910;
}


ves_icall_System_Diagnostics_Debugger_IsAttached_internal ()
{
  MonoBoolean D.30915;
  int D.30916;

  D.30916 = mono_is_debugger_attached ();
  D.30915 = (MonoBoolean) D.30916;
  return D.30915;
}


ves_icall_System_Delegate_SetMulticastInvoke (struct MonoDelegate * this)
{
  struct MonoVTable * D.30918;
  struct MonoClass * D.30919;
  void * D.30920;

  D.30918 = this->object.vtable;
  D.30919 = D.30918->klass;
  D.30920 = mono_runtime_create_delegate_trampoline (D.30919);
  this->invoke_impl = D.30920;
}


ves_icall_System_Delegate_CreateDelegate_internal (struct MonoReflectionType * type, struct MonoObject * target, struct MonoReflectionMethod * info, MonoBoolean throwOnBindFailure)
{
  struct MonoType * D.30921;
  struct MonoClass * D.30922;
  struct MonoClass * D.30923;
  <unnamed type> D.30926;
  int D.30929;
  int D.30930;
  struct MonoObject * D.30933;
  struct MonoVTable * D.30934;
  struct MonoDomain * D.30935;
  unsigned int D.30936;
  unsigned int D.30937;
  short unsigned int D.30943;
  int D.30944;
  int D.30945;
  struct MonoClass * D.30948;
  struct MonoVTable * D.30949;
  struct MonoClass * D.30950;
  struct MonoDomain * D.30953;
  struct MonoDomain * D.30954;
  void * D.30955;
  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.30921 = type->type;
  delegate_class = mono_class_from_mono_type (D.30921);
  method = info->method;
  mono_class_init_or_throw (delegate_class);
  D.30922 = delegate_class->parent;
  D.30923 = mono_defaults.multicastdelegate_class;
  if (D.30922 != D.30923) goto <D.30924>; else goto <D.30925>;
  <D.30924>:
  {
    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.30925>:
  D.30926 = mono_security_get_mode ();
  if (D.30926 == 1) goto <D.30927>; else goto <D.30928>;
  <D.30927>:
  D.30929 = (int) throwOnBindFailure;
  D.30930 = mono_security_core_clr_ensure_delegate_creation (method, D.30929);
  if (D.30930 == 0) goto <D.30931>; else goto <D.30932>;
  <D.30931>:
  D.30933 = 0B;
  return D.30933;
  <D.30932>:
  <D.30928>:
  D.30934 = MEM[(struct MonoObject *)type].vtable;
  D.30935 = D.30934->domain;
  delegate = mono_object_new (D.30935, delegate_class);
  D.30936 = BIT_FIELD_REF <*method, 32, 160>;
  D.30937 = D.30936 & 512;
  if (D.30937 != 0) goto <D.30938>; else goto <D.30939>;
  <D.30938>:
  func = mono_compile_method (method);
  goto <D.30940>;
  <D.30939>:
  if (target != 0B) goto <D.30941>; else goto <D.30942>;
  <D.30941>:
  D.30943 = method->flags;
  D.30944 = (int) D.30943;
  D.30945 = D.30944 & 64;
  if (D.30945 != 0) goto <D.30946>; else goto <D.30947>;
  <D.30946>:
  D.30948 = method->klass;
  D.30949 = target->vtable;
  D.30950 = D.30949->klass;
  if (D.30948 != D.30950) goto <D.30951>; else goto <D.30952>;
  <D.30951>:
  method = mono_object_get_virtual_method (target, method);
  <D.30952>:
  <D.30947>:
  <D.30942>:
  D.30953 = mono_domain_get ();
  D.30954 = mono_domain_get ();
  D.30955 = mono_runtime_create_jump_trampoline (D.30954, method, 1);
  func = mono_create_ftnptr (D.30953, D.30955);
  <D.30940>:
  mono_delegate_ctor_with_method (delegate, target, func, method);
  D.30933 = delegate;
  return D.30933;
}


ves_icall_System_CurrentSystemTimeZone_GetTimeZoneData (guint32 year, struct MonoArray * * data, struct MonoArray * * names)
{
  _Bool D.30957;
  long int D.30958;
  long int D.30959;
  _Bool D.30964;
  long int D.30965;
  long int D.30966;
  struct MonoClass * D.30971;
  struct MonoArray * D.30972;
  struct MonoClass * D.30973;
  struct MonoArray * D.30974;
  unsigned int D.30975;
  int D.30976;
  long int t.272;
  unsigned int D.30980;
  long int t.273;
  long int t.274;
  struct tm * D.30984;
  struct MonoArray * D.30985;
  struct MonoString * D.30986;
  struct MonoString * D.30987;
  guint32 D.30988;
  long int t.275;
  struct tm * D.30990;
  long int t1.276;
  long int t1.277;
  struct tm * D.30995;
  int D.30996;
  long int t1.278;
  struct tm * D.30998;
  int D.30999;
  long int t1.279;
  int D.31001;
  struct MonoString * D.31004;
  struct MonoArray * D.31005;
  long long unsigned int D.31006;
  long long unsigned int D.31007;
  long long unsigned int D.31008;
  long long int D.31009;
  struct MonoString * D.31013;
  int D.31016;
  long long int D.31019;
  long long int D.31020;
  long int D.31021;
  long long int D.31022;
  long long int D.31023;
  struct MonoString * D.31027;
  struct MonoString * D.31028;
  long long int D.31029;
  long long int D.31030;
  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.30957 = data == 0B;
      D.30958 = (long int) D.30957;
      D.30959 = __builtin_expect (D.30958, 0);
      if (D.30959 != 0) goto <D.30960>; else goto <D.30961>;
      <D.30960>:
      {
        struct MonoException * ex;

        if (data != 0B) goto <D.30962>; else goto <D.30963>;
        <D.30962>:
        <D.30963>:
        ex = mono_get_exception_argument_null ("data");
        mono_raise_exception (ex);
      }
      <D.30961>:
      D.30964 = names == 0B;
      D.30965 = (long int) D.30964;
      D.30966 = __builtin_expect (D.30965, 0);
      if (D.30966 != 0) goto <D.30967>; else goto <D.30968>;
      <D.30967>:
      {
        struct MonoException * ex;

        if (names != 0B) goto <D.30969>; else goto <D.30970>;
        <D.30969>:
        <D.30970>:
        ex = mono_get_exception_argument_null ("names");
        mono_raise_exception (ex);
      }
      <D.30968>:
      D.30971 = mono_defaults.int64_class;
      D.30972 = mono_array_new (domain, D.30971, 4);
      mono_gc_wbarrier_generic_store (data, D.30972);
      D.30973 = mono_defaults.string_class;
      D.30974 = mono_array_new (domain, D.30973, 2);
      mono_gc_wbarrier_generic_store (names, D.30974);
      memset (&start, 0, 44);
      start.tm_mday = 1;
      D.30975 = year + 4294965396;
      D.30976 = (int) D.30975;
      start.tm_year = D.30976;
      t.272 = mktime (&start);
      t = t.272;
      D.30980 = year + 4294965326;
      if (D.30980 > 67) goto <D.30978>; else goto <D.30981>;
      <D.30981>:
      t.273 = t;
      if (t.273 == -1) goto <D.30978>; else goto <D.30979>;
      <D.30978>:
      t.274 = time (0B);
      t = t.274;
      D.30984 = localtime (&t);
      tt = *D.30984;
      strftime (&tzone, 64, "%Z", &tt);
      {
        void * * __p;

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

        D.30985 = *names;
        __p = mono_array_addr_with_size (D.30985, 4, 1);
        D.30985 = *names;
        D.30987 = mono_string_new (domain, &tzone);
        mono_gc_wbarrier_set_arrayref (D.30985, __p, D.30987);
      }
      D.30988 = 1;
      return D.30988;
      <D.30979>:
      t.273 = t;
      gmtoff = gmt_offset (&start, t.273);
      day = 0;
      goto <D.22737>;
      <D.22736>:
      t.273 = t;
      t.275 = t.273 + 86400;
      t = t.275;
      D.30990 = localtime (&t);
      tt = *D.30990;
      t.273 = t;
      gmtoff_after = gmt_offset (&tt, t.273);
      if (gmtoff_after != gmtoff) goto <D.30991>; else goto <D.30992>;
      <D.30991>:
      {
        struct tm tt1;
        time_t t1;

        try
          {
            t.273 = t;
            t1 = t.273;
            <D.22725>:
            t1.276 = t1;
            t1.277 = t1.276 + -3600;
            t1 = t1.277;
            D.30995 = localtime (&t1);
            tt1 = *D.30995;
            t1.276 = t1;
            D.30996 = gmt_offset (&tt1, t1.276);
            if (D.30996 != gmtoff) goto <D.22725>; else goto <D.22726>;
            <D.22726>:
            <D.22727>:
            t1.276 = t1;
            t1.278 = t1.276 + 60;
            t1 = t1.278;
            D.30998 = localtime (&t1);
            tt1 = *D.30998;
            t1.276 = t1;
            D.30999 = gmt_offset (&tt1, t1.276);
            if (D.30999 == gmtoff) goto <D.22727>; else goto <D.22728>;
            <D.22728>:
            t1.276 = t1;
            t1.279 = t1.276 + gmtoff;
            t1 = t1.279;
            strftime (&tzone, 64, "%Z", &tt);
            D.31001 = tt.tm_isdst;
            if (D.31001 != 0) goto <D.31002>; else goto <D.31003>;
            <D.31002>:
            {
              void * * __p;

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

              D.31005 = *data;
              __p = mono_array_addr_with_size (D.31005, 8, 0);
              t1.276 = t1;
              D.31006 = (long long unsigned int) t1.276;
              D.31007 = D.31006 * 10000000;
              D.31008 = D.31007 + 621355968000000000;
              D.31009 = (long long int) D.31008;
              *__p = D.31009;
            }
            if (gmtoff_ds == 0) goto <D.31010>; else goto <D.31011>;
            <D.31010>:
            gmtoff_st = gmtoff;
            gmtoff_ds = gmtoff_after;
            <D.31011>:
            transitioned = transitioned + 1;
            goto <D.31012>;
            <D.31003>:
            {
              time_t te;

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

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

                D.31005 = *data;
                __p = mono_array_addr_with_size (D.31005, 8, 1);
                t1.276 = t1;
                D.31006 = (long long unsigned int) t1.276;
                D.31007 = D.31006 * 10000000;
                D.31008 = D.31007 + 621355968000000000;
                D.31009 = (long long int) D.31008;
                *__p = D.31009;
              }
              if (gmtoff_ds == 0) goto <D.31014>; else goto <D.31015>;
              <D.31014>:
              gmtoff_st = gmtoff_after;
              gmtoff_ds = gmtoff;
              <D.31015>:
              transitioned = transitioned + 1;
            }
            <D.31012>:
            D.31016 = tt1.tm_isdst;
            if (D.31016 != 0) goto <D.31017>; else goto <D.31018>;
            <D.31017>:
            {
              gint64 * __p;

              D.31005 = *data;
              __p = mono_array_addr_with_size (D.31005, 8, 2);
              D.31019 = (long long int) gmtoff_st;
              D.31020 = D.31019 * 10000000;
              *__p = D.31020;
            }
            {
              gint64 * __p;

              D.31005 = *data;
              __p = mono_array_addr_with_size (D.31005, 8, 3);
              D.31021 = gmtoff_ds - gmtoff_st;
              D.31022 = (long long int) D.31021;
              D.31023 = D.31022 * 10000000;
              *__p = D.31023;
            }
            <D.31018>:
            t.273 = t;
            gmtoff = gmt_offset (&tt, t.273);
          }
        finally
          {
            tt1 = {CLOBBER};
            t1 = {CLOBBER};
          }
      }
      <D.30992>:
      day = day + 1;
      <D.22737>:
      if (day <= 364) goto <D.31024>; else goto <D.22738>;
      <D.31024>:
      if (transitioned <= 1) goto <D.22736>; else goto <D.22738>;
      <D.22738>:
      if (transitioned <= 1) goto <D.31025>; else goto <D.31026>;
      <D.31025>:
      strftime (&tzone, 64, "%Z", &tt);
      {
        void * * __p;

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

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

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

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

        D.31005 = *data;
        __p = mono_array_addr_with_size (D.31005, 8, 2);
        D.31029 = (long long int) gmtoff;
        D.31030 = D.31029 * 10000000;
        *__p = D.31030;
      }
      {
        gint64 * __p;

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


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

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


InternalFromBase64String (struct MonoString * str, MonoBoolean allowWhitespaceOnly)
{
  struct MonoArray * D.31035;
  mono_unichar2 * D.31036;
  int D.31037;
  int D.31038;

  D.31036 = mono_string_chars (str);
  D.31037 = mono_string_length (str);
  D.31038 = (int) allowWhitespaceOnly;
  D.31035 = base64_to_byte_array (D.31036, D.31037, D.31038);
  return D.31035;
}


base64_to_byte_array (gunichar2 * start, gint ilength, MonoBoolean allowWhitespaceOnly)
{
  unsigned int i.280;
  unsigned int D.31041;
  gunichar2 * D.31042;
  struct MonoImage * D.31045;
  const short unsigned int * * D.31047;
  const short unsigned int * D.31048;
  unsigned int D.31049;
  unsigned int D.31050;
  const short unsigned int * D.31051;
  short unsigned int D.31052;
  int D.31053;
  int D.31054;
  struct MonoImage * D.31062;
  struct MonoArray * D.31069;
  struct MonoDomain * D.31070;
  struct MonoClass * D.31071;
  int D.31074;
  struct MonoImage * D.31076;
  struct MonoImage * D.31079;
  int D.31080;
  struct MonoDomain * D.31085;
  unsigned int olength.281;
  int i.282;
  unsigned int i.283;
  unsigned int D.31089;
  gunichar2 * D.31090;
  unsigned char D.31093;
  int D.31094;
  int D.31095;
  unsigned char D.31096;
  int D.31097;
  int D.31098;
  int D.31099;
  struct MonoImage * D.31102;
  guchar * res_ptr.284;
  int D.31105;
  int D.31106;
  signed char D.31107;
  int D.31108;
  int D.31109;
  signed char D.31110;
  signed char D.31111;
  unsigned char D.31112;
  int D.31113;
  guchar * res_ptr.285;
  int D.31117;
  signed char D.31118;
  int D.31119;
  int D.31120;
  signed char D.31121;
  signed char D.31122;
  unsigned char D.31123;
  int D.31124;
  guchar * res_ptr.286;
  int D.31128;
  signed char D.31129;
  int D.31130;
  signed char D.31131;
  signed char D.31132;
  unsigned char D.31133;
  short unsigned int D.31135;
  unsigned int D.31136;
  unsigned int D.31137;
  const short unsigned int * D.31138;
  short unsigned int D.31139;
  int D.31140;
  int D.31141;
  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.23249>;
      <D.23248>:
      i.280 = (unsigned int) i;
      D.31041 = i.280 * 2;
      D.31042 = start + D.31041;
      c = *D.31042;
      if (c > 122) goto <D.31043>; else goto <D.31044>;
      <D.31043>:
      D.31045 = mono_get_corlib ();
      exc = mono_exception_from_name_msg (D.31045, "System", "FormatException", "Invalid character found.");
      mono_raise_exception (exc);
      goto <D.31046>;
      <D.31044>:
      D.31047 = __ctype_b_loc ();
      D.31048 = *D.31047;
      D.31049 = (unsigned int) c;
      D.31050 = D.31049 * 2;
      D.31051 = D.31048 + D.31050;
      D.31052 = *D.31051;
      D.31053 = (int) D.31052;
      D.31054 = D.31053 & 8192;
      if (D.31054 != 0) goto <D.31055>; else goto <D.31056>;
      <D.31055>:
      ignored = ignored + 1;
      goto <D.31057>;
      <D.31056>:
      if (havePadding != 0) goto <D.31060>; else goto <D.31058>;
      <D.31060>:
      if (c != 61) goto <D.31061>; else goto <D.31058>;
      <D.31061>:
      D.31062 = mono_get_corlib ();
      exc = mono_exception_from_name_msg (D.31062, "System", "FormatException", "Invalid character found.");
      mono_raise_exception (exc);
      goto <D.31059>;
      <D.31058>:
      if (c == 61) goto <D.31063>; else goto <D.31064>;
      <D.31063>:
      havePadding = 1;
      <D.31064>:
      prev2_last = prev_last;
      prev_last = last;
      last = c;
      <D.31059>:
      <D.31057>:
      <D.31046>:
      i = i + 1;
      <D.23249>:
      if (i < ilength) goto <D.23248>; else goto <D.23250>;
      <D.23250>:
      olength = ilength - ignored;
      if (allowWhitespaceOnly != 0) goto <D.31065>; else goto <D.31066>;
      <D.31065>:
      if (olength == 0) goto <D.31067>; else goto <D.31068>;
      <D.31067>:
      D.31070 = mono_domain_get ();
      D.31071 = mono_defaults.byte_class;
      D.31069 = mono_array_new (D.31070, D.31071, 0);
      return D.31069;
      <D.31068>:
      <D.31066>:
      D.31074 = olength & 3;
      if (D.31074 != 0) goto <D.31072>; else goto <D.31075>;
      <D.31075>:
      if (olength <= 0) goto <D.31072>; else goto <D.31073>;
      <D.31072>:
      D.31076 = mono_get_corlib ();
      exc = mono_exception_from_name_msg (D.31076, "System", "FormatException", "Invalid length.");
      mono_raise_exception (exc);
      <D.31073>:
      if (prev2_last == 61) goto <D.31077>; else goto <D.31078>;
      <D.31077>:
      D.31079 = mono_get_corlib ();
      exc = mono_exception_from_name_msg (D.31079, "System", "FormatException", "Invalid format.");
      mono_raise_exception (exc);
      <D.31078>:
      D.31080 = olength * 3;
      olength = D.31080 / 4;
      if (last == 61) goto <D.31081>; else goto <D.31082>;
      <D.31081>:
      olength = olength + -1;
      <D.31082>:
      if (prev_last == 61) goto <D.31083>; else goto <D.31084>;
      <D.31083>:
      olength = olength + -1;
      <D.31084>:
      D.31085 = mono_domain_get ();
      D.31071 = mono_defaults.byte_class;
      olength.281 = (unsigned int) olength;
      result = mono_array_new (D.31085, D.31071, olength.281);
      res_ptr = mono_array_addr_with_size (result, 1, 0);
      i = 0;
      goto <D.23259>;
      <D.23258>:
      {
        int k;

        k = 0;
        goto <D.23252>;
        <D.23253>:
        i.282 = i;
        i = i.282 + 1;
        i.283 = (unsigned int) i.282;
        D.31089 = i.283 * 2;
        D.31090 = start + D.31089;
        c = *D.31090;
        D.31047 = __ctype_b_loc ();
        D.31048 = *D.31047;
        D.31049 = (unsigned int) c;
        D.31050 = D.31049 * 2;
        D.31051 = D.31048 + D.31050;
        D.31052 = *D.31051;
        D.31053 = (int) D.31052;
        D.31054 = D.31053 & 8192;
        if (D.31054 != 0) goto <D.31091>; else goto <D.31092>;
        <D.31091>:
        // predicted unlikely by continue predictor.
        goto <D.23252>;
        <D.31092>:
        D.31093 = (unsigned char) c;
        D.31094 = (int) D.31093;
        a[k] = D.31094;
        D.31095 = (int) c;
        D.31096 = dbase64[D.31095];
        D.31097 = (int) D.31096;
        b[k] = D.31097;
        D.31098 = b[k];
        D.31099 = D.31098 & 128;
        if (D.31099 != 0) goto <D.31100>; else goto <D.31101>;
        <D.31100>:
        D.31102 = mono_get_corlib ();
        exc = mono_exception_from_name_msg (D.31102, "System", "FormatException", "Invalid character found.");
        mono_raise_exception (exc);
        <D.31101>:
        k = k + 1;
        <D.23252>:
        if (k <= 3) goto <D.31103>; else goto <D.23254>;
        <D.31103>:
        if (i < ilength) goto <D.23253>; else goto <D.23254>;
        <D.23254>:
        res_ptr.284 = res_ptr;
        res_ptr = res_ptr.284 + 1;
        D.31105 = b[0];
        D.31106 = D.31105 << 2;
        D.31107 = (signed char) D.31106;
        D.31108 = b[1];
        D.31109 = D.31108 >> 4;
        D.31110 = (signed char) D.31109;
        D.31111 = D.31107 | D.31110;
        D.31112 = (unsigned char) D.31111;
        *res_ptr.284 = D.31112;
        D.31113 = a[2];
        if (D.31113 != 61) goto <D.31114>; else goto <D.31115>;
        <D.31114>:
        res_ptr.285 = res_ptr;
        res_ptr = res_ptr.285 + 1;
        D.31108 = b[1];
        D.31117 = D.31108 << 4;
        D.31118 = (signed char) D.31117;
        D.31119 = b[2];
        D.31120 = D.31119 >> 2;
        D.31121 = (signed char) D.31120;
        D.31122 = D.31118 | D.31121;
        D.31123 = (unsigned char) D.31122;
        *res_ptr.285 = D.31123;
        <D.31115>:
        D.31124 = a[3];
        if (D.31124 != 61) goto <D.31125>; else goto <D.31126>;
        <D.31125>:
        res_ptr.286 = res_ptr;
        res_ptr = res_ptr.286 + 1;
        D.31119 = b[2];
        D.31128 = D.31119 << 6;
        D.31129 = (signed char) D.31128;
        D.31130 = b[3];
        D.31131 = (signed char) D.31130;
        D.31132 = D.31129 | D.31131;
        D.31133 = (unsigned char) D.31132;
        *res_ptr.286 = D.31133;
        <D.31126>:
        goto <D.23256>;
        <D.23255>:
        i = i + 1;
        <D.23256>:
        if (i < ilength) goto <D.31134>; else goto <D.23257>;
        <D.31134>:
        D.31047 = __ctype_b_loc ();
        D.31048 = *D.31047;
        i.280 = (unsigned int) i;
        D.31041 = i.280 * 2;
        D.31042 = start + D.31041;
        D.31135 = *D.31042;
        D.31136 = (unsigned int) D.31135;
        D.31137 = D.31136 * 2;
        D.31138 = D.31048 + D.31137;
        D.31139 = *D.31138;
        D.31140 = (int) D.31139;
        D.31141 = D.31140 & 8192;
        if (D.31141 != 0) goto <D.23255>; else goto <D.23257>;
        <D.23257>:
      }
      <D.23259>:
      if (i < ilength) goto <D.23258>; else goto <D.23260>;
      <D.23260>:
      D.31069 = result;
      return D.31069;
    }
  finally
    {
      a = {CLOBBER};
      b = {CLOBBER};
    }
}


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

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


get_bundled_app_config ()
{
  struct MonoAppDomainSetup * D.31148;
  struct MonoString * D.31151;
  unsigned int D.31154;
  unsigned int D.31155;
  struct MonoDomain * D.31160;
  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.31148 = domain->setup;
  file = D.31148->configuration_file;
  if (file == 0B) goto <D.31149>; else goto <D.31150>;
  <D.31149>:
  D.31151 = 0B;
  return D.31151;
  <D.31150>:
  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.31152>; else goto <D.31153>;
  <D.31152>:
  config_file_path = config_file_name;
  <D.31153>:
  D.31154 = strlen (config_file_path);
  len = D.31154 + 4294967289;
  D.31155 = len + 1;
  module = monoeg_malloc0 (D.31155);
  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.31156>; else goto <D.31157>;
  <D.31156>:
  monoeg_g_free (config_file_name);
  <D.31157>:
  monoeg_g_free (config_file_path);
  if (app_config == 0B) goto <D.31158>; else goto <D.31159>;
  <D.31158>:
  D.31151 = 0B;
  return D.31151;
  <D.31159>:
  D.31160 = mono_domain_get ();
  D.31151 = mono_string_new (D.31160, app_config);
  return D.31151;
}


ves_icall_System_Configuration_DefaultConfig_get_machine_config_path ()
{
  const char * D.31162;
  const struct MonoRuntimeInfo * D.31163;
  const char[4] * D.31164;
  struct MonoDomain * D.31165;
  struct MonoString * D.31166;
  struct MonoString * mcpath;
  gchar * path;

  D.31162 = mono_get_config_dir ();
  D.31163 = mono_get_runtime_info ();
  D.31164 = &D.31163->framework_version;
  path = monoeg_g_build_path ("/", D.31162, "mono", D.31164, "machine.config", 0B);
  D.31165 = mono_domain_get ();
  mcpath = mono_string_new (D.31165, path);
  monoeg_g_free (path);
  D.31166 = mcpath;
  return D.31166;
}


get_bundled_machine_config ()
{
  struct MonoString * D.31170;
  struct MonoDomain * D.31171;
  const gchar * machine_config;

  machine_config = mono_get_machine_config ();
  if (machine_config == 0B) goto <D.31168>; else goto <D.31169>;
  <D.31168>:
  D.31170 = 0B;
  return D.31170;
  <D.31169>:
  D.31171 = mono_domain_get ();
  D.31170 = mono_string_new (D.31171, machine_config);
  return D.31170;
}


ves_icall_System_ComponentModel_Win32Exception_W32ErrorMessage (guint32 code)
{
  struct MonoDomain * D.31175;
  struct MonoDomain * D.31177;
  int ret.288;
  struct MonoString * D.31179;
  struct MonoString * message;
  guint32 ret;
  gunichar2 buf[256];

  try
    {
      ret = FormatMessage (4608, 0B, code, 0, &buf, 255, 0B);
      if (ret == 0) goto <D.31173>; else goto <D.31174>;
      <D.31173>:
      D.31175 = mono_domain_get ();
      message = mono_string_new (D.31175, "Error looking up error string");
      goto <D.31176>;
      <D.31174>:
      D.31177 = mono_domain_get ();
      ret.288 = (int) ret;
      message = mono_string_new_utf16 (D.31177, &buf, ret.288);
      <D.31176>:
      D.31179 = message;
      return D.31179;
    }
  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.31182>; else goto <D.31183>;
  <D.31182>:
  *category_data = &CategoryData_v4;
  *category_astral_index = &CategoryData_v4_astral_index;
  return;
  <D.31183>:
  *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.31186;
  unsigned int idx.290;
  char * D.31188;

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


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

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


mono_array_get_byte_length (struct MonoArray * array)
{
  struct MonoVTable * D.31192;
  struct MonoArrayBounds * D.31193;
  unsigned int D.31196;
  unsigned int i.291;
  unsigned int D.31199;
  struct MonoArrayBounds * D.31200;
  unsigned int D.31201;
  unsigned int length.292;
  unsigned int D.31203;
  unsigned char D.31204;
  int D.31205;
  struct MonoClass * D.31206;
  unsigned char D.31207;
  int D.31208;
  gint32 D.31209;
  unsigned int length.293;
  unsigned int D.31211;
  struct MonoClass * klass;
  int length;
  int i;

  D.31192 = array->obj.vtable;
  klass = D.31192->klass;
  D.31193 = array->bounds;
  if (D.31193 == 0B) goto <D.31194>; else goto <D.31195>;
  <D.31194>:
  D.31196 = array->max_length;
  length = (int) D.31196;
  goto <D.31197>;
  <D.31195>:
  length = 1;
  i = 0;
  goto <D.22755>;
  <D.22754>:
  D.31193 = array->bounds;
  i.291 = (unsigned int) i;
  D.31199 = i.291 * 8;
  D.31200 = D.31193 + D.31199;
  D.31201 = D.31200->length;
  length.292 = (unsigned int) length;
  D.31203 = D.31201 * length.292;
  length = (int) D.31203;
  i = i + 1;
  <D.22755>:
  D.31204 = klass->rank;
  D.31205 = (int) D.31204;
  if (D.31205 > i) goto <D.22754>; else goto <D.22756>;
  <D.22756>:
  <D.31197>:
  D.31206 = klass->element_class;
  D.31207 = D.31206->byval_arg.type;
  D.31208 = (int) D.31207;
  switch (D.31208) <default: <D.22771>, case 2: <D.22759>, case 3: <D.22762>, case 4: <D.22757>, case 5: <D.22758>, case 6: <D.22760>, case 7: <D.22761>, case 8: <D.22763>, case 9: <D.22764>, case 10: <D.22768>, case 11: <D.22769>, case 12: <D.22765>, case 13: <D.22770>, case 24: <D.22766>, case 25: <D.22767>>
  <D.22757>:
  <D.22758>:
  <D.22759>:
  D.31209 = length;
  return D.31209;
  <D.22760>:
  <D.22761>:
  <D.22762>:
  D.31209 = length << 1;
  return D.31209;
  <D.22763>:
  <D.22764>:
  <D.22765>:
  D.31209 = length << 2;
  return D.31209;
  <D.22766>:
  <D.22767>:
  length.293 = (unsigned int) length;
  D.31211 = length.293 * 4;
  D.31209 = (gint32) D.31211;
  return D.31209;
  <D.22768>:
  <D.22769>:
  <D.22770>:
  D.31209 = length << 3;
  return D.31209;
  <D.22771>:
  D.31209 = -1;
  return D.31209;
}


ves_icall_System_Buffer_BlockCopyInternal (struct MonoArray * src, gint32 src_offset, struct MonoArray * dest, gint32 dest_offset, gint32 count)
{
  _Bool D.31213;
  long int D.31214;
  long int D.31215;
  _Bool D.31220;
  long int D.31221;
  long int D.31222;
  int D.31229;
  int D.31230;
  int D.31232;
  int D.31233;
  MonoBoolean D.31234;
  double[0:] * D.31235;
  sizetype src_offset.294;
  double[0:] * D.31237;
  sizetype dest_offset.295;
  unsigned int count.296;
  guint8 * src_buf;
  guint8 * dest_buf;

  D.31213 = src == 0B;
  D.31214 = (long int) D.31213;
  D.31215 = __builtin_expect (D.31214, 0);
  if (D.31215 != 0) goto <D.31216>; else goto <D.31217>;
  <D.31216>:
  {
    struct MonoException * ex;

    if (src != 0B) goto <D.31218>; else goto <D.31219>;
    <D.31218>:
    <D.31219>:
    ex = mono_get_exception_argument_null ("src");
    mono_raise_exception (ex);
  }
  <D.31217>:
  D.31220 = dest == 0B;
  D.31221 = (long int) D.31220;
  D.31222 = __builtin_expect (D.31221, 0);
  if (D.31222 != 0) goto <D.31223>; else goto <D.31224>;
  <D.31223>:
  {
    struct MonoException * ex;

    if (dest != 0B) goto <D.31225>; else goto <D.31226>;
    <D.31225>:
    <D.31226>:
    ex = mono_get_exception_argument_null ("dest");
    mono_raise_exception (ex);
  }
  <D.31224>:
  D.31229 = mono_array_get_byte_length (src);
  D.31230 = D.31229 - count;
  if (D.31230 < src_offset) goto <D.31227>; else goto <D.31231>;
  <D.31231>:
  D.31232 = mono_array_get_byte_length (dest);
  D.31233 = D.31232 - count;
  if (D.31233 < dest_offset) goto <D.31227>; else goto <D.31228>;
  <D.31227>:
  D.31234 = 0;
  return D.31234;
  <D.31228>:
  D.31235 = &src->vector;
  src_offset.294 = (sizetype) src_offset;
  src_buf = D.31235 + src_offset.294;
  D.31237 = &dest->vector;
  dest_offset.295 = (sizetype) dest_offset;
  dest_buf = D.31237 + dest_offset.295;
  if (src != dest) goto <D.31239>; else goto <D.31240>;
  <D.31239>:
  count.296 = (unsigned int) count;
  memcpy (dest_buf, src_buf, count.296);
  goto <D.31242>;
  <D.31240>:
  count.296 = (unsigned int) count;
  memmove (dest_buf, src_buf, count.296);
  <D.31242>:
  D.31234 = 1;
  return D.31234;
}


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

  D.31245 = __builtin_object_size (__dest, 0);
  D.31244 = __builtin___memmove_chk (__dest, __src, __len, D.31245);
  return D.31244;
}


ves_icall_System_Array_SetValueImpl (struct MonoArray * this, struct MonoObject * value, guint32 pos)
{
  struct MonoVTable * D.31249;
  struct MonoVTable * D.31251;
  double[0:] * D.31252;
  unsigned int esize.297;
  unsigned int D.31254;
  int D.31255;
  unsigned int esize.298;
  unsigned char D.31261;
  int D.31262;
  unsigned char D.31263;
  int D.31264;
  struct MonoRuntimeCallbacks * D.31265;
  void (*<T26f0>) (struct MonoClass *, struct MonoClass *) D.31266;
  struct MonoException * D.31267;
  struct MonoException * D.31268;
  struct MonoRuntimeCallbacks * D.31269;
  void (*<T26f0>) (struct MonoClass *, struct MonoClass *) D.31270;
  struct MonoException * D.31271;
  unsigned int D.31273;
  unsigned int D.31274;
  struct MonoObject * D.31277;
  struct MonoRuntimeCallbacks * D.31280;
  void (*<T26f0>) (struct MonoClass *, struct MonoClass *) D.31281;
  struct MonoException * D.31282;
  struct MonoObject * D.31283;
  unsigned int D.31286;
  void * D.31289;
  const void * D.31291;
  unsigned int D.31292;
  unsigned int D.31293;
  struct MonoRuntimeCallbacks * D.31296;
  void (*<T26f0>) (struct MonoClass *, struct MonoClass *) D.31297;
  struct MonoException * D.31298;
  int D.31299;
  unsigned int D.31300;
  unsigned int D.31301;
  struct MonoClass * D.31304;
  unsigned int D.31305;
  unsigned int D.31306;
  struct MonoType * D.31309;
  unsigned char D.31310;
  struct MonoClass * D.31313;
  unsigned int D.31314;
  unsigned int D.31315;
  struct MonoType * D.31318;
  unsigned char D.31319;
  unsigned char D.31320;
  short unsigned int D.31321;
  unsigned int D.31322;
  signed char D.31323;
  short int D.31324;
  int D.31325;
  float D.31326;
  struct MonoException * D.31327;
  struct MonoRuntimeCallbacks * D.31328;
  void (*<T26f0>) (struct MonoClass *, struct MonoClass *) D.31329;
  struct MonoException * D.31330;
  struct MonoException * D.31334;
  short unsigned int D.31335;
  struct MonoException * D.31336;
  struct MonoException * D.31340;
  unsigned char D.31341;
  struct MonoException * D.31342;
  struct MonoException * D.31346;
  struct MonoException * D.31347;
  struct MonoException * D.31351;
  unsigned int D.31352;
  struct MonoException * D.31353;
  struct MonoException * D.31357;
  struct MonoException * D.31358;
  struct MonoException * D.31362;
  signed char D.31363;
  struct MonoException * D.31366;
  signed char D.31367;
  struct MonoException * D.31368;
  struct MonoException * D.31372;
  short int D.31373;
  struct MonoException * D.31376;
  short int D.31377;
  struct MonoException * D.31378;
  struct MonoException * D.31382;
  int D.31383;
  struct MonoException * D.31386;
  int D.31387;
  struct MonoException * D.31388;
  struct MonoException * D.31392;
  struct MonoException * D.31395;
  long long int u64.299;
  struct MonoException * D.31397;
  struct MonoException * D.31401;
  float D.31402;
  float D.31403;
  float D.31404;
  struct MonoException * D.31408;
  double D.31409;
  double D.31410;
  struct MonoRuntimeCallbacks * D.31413;
  void (*<T26f0>) (struct MonoClass *, struct MonoClass *) D.31414;
  struct MonoException * D.31415;
  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.31247>; else goto <D.31248>;
  <D.31247>:
  D.31249 = value->vtable;
  vc = D.31249->klass;
  goto <D.31250>;
  <D.31248>:
  vc = 0B;
  <D.31250>:
  D.31251 = this->obj.vtable;
  ac = D.31251->klass;
  ec = ac->element_class;
  esize = mono_array_element_size (ac);
  D.31252 = &this->vector;
  esize.297 = (unsigned int) esize;
  D.31254 = pos * esize.297;
  ea = D.31252 + D.31254;
  va = value + 8;
  D.31255 = mono_class_is_nullable (ec);
  if (D.31255 != 0) goto <D.31256>; else goto <D.31257>;
  <D.31256>:
  mono_nullable_init (ea, value, ec);
  return;
  <D.31257>:
  if (value == 0B) goto <D.31258>; else goto <D.31259>;
  <D.31258>:
  esize.298 = (unsigned int) esize;
  mono_gc_bzero_atomic (ea, esize.298);
  return;
  <D.31259>:
  D.31261 = ec->byval_arg.type;
  D.31262 = (int) D.31261;
  switch (D.31262) <default: <D.31272>, case 2: <D.20349>, case 14: <D.20344>>
  <D.20344>:
  D.31263 = vc->byval_arg.type;
  D.31264 = (int) D.31263;
  switch (D.31264) <default: <D.20347>, case 14: <D.20345>>
  <D.20345>:
  goto <D.20346>;
  <D.20347>:
  D.31265 = mono_get_runtime_callbacks ();
  D.31266 = D.31265->set_cast_details;
  D.31266 (vc, ec);
  D.31267 = mono_get_exception_invalid_cast ();
  mono_raise_exception (D.31267);
  <D.20346>:
  goto <D.20348>;
  <D.20349>:
  D.31263 = vc->byval_arg.type;
  D.31264 = (int) D.31263;
  switch (D.31264) <default: <D.20363>, case 2: <D.20350>, case 3: <D.20352>, case 4: <D.20357>, case 5: <D.20353>, case 6: <D.20358>, case 7: <D.20354>, case 8: <D.20359>, case 9: <D.20355>, case 10: <D.20360>, case 11: <D.20356>, case 12: <D.20361>, case 13: <D.20362>>
  <D.20350>:
  goto <D.20351>;
  <D.20352>:
  <D.20353>:
  <D.20354>:
  <D.20355>:
  <D.20356>:
  <D.20357>:
  <D.20358>:
  <D.20359>:
  <D.20360>:
  <D.20361>:
  <D.20362>:
  D.31268 = mono_get_exception_argument ("value", "not a widening conversion");
  mono_raise_exception (D.31268);
  <D.20363>:
  D.31269 = mono_get_runtime_callbacks ();
  D.31270 = D.31269->set_cast_details;
  D.31270 (vc, ec);
  D.31271 = mono_get_exception_invalid_cast ();
  mono_raise_exception (D.31271);
  <D.20351>:
  goto <D.20348>;
  <D.31272>:
  <D.20348>:
  D.31273 = BIT_FIELD_REF <*ec, 32, 160>;
  D.31274 = D.31273 & 8;
  if (D.31274 == 0) goto <D.31275>; else goto <D.31276>;
  <D.31275>:
  D.31277 = mono_object_isinst (value, ec);
  if (D.31277 == 0B) goto <D.31278>; else goto <D.31279>;
  <D.31278>:
  D.31280 = mono_get_runtime_callbacks ();
  D.31281 = D.31280->set_cast_details;
  D.31281 (vc, ec);
  D.31282 = mono_get_exception_invalid_cast ();
  mono_raise_exception (D.31282);
  <D.31279>:
  mono_gc_wbarrier_set_arrayref (this, ea, value);
  return;
  <D.31276>:
  D.31283 = mono_object_isinst (value, ec);
  if (D.31283 != 0B) goto <D.31284>; else goto <D.31285>;
  <D.31284>:
  D.31273 = BIT_FIELD_REF <*ec, 32, 160>;
  D.31286 = D.31273 & 134217728;
  if (D.31286 != 0) goto <D.31287>; else goto <D.31288>;
  <D.31287>:
  D.31289 = value + 8;
  mono_value_copy (ea, D.31289, ec);
  goto <D.31290>;
  <D.31288>:
  D.31291 = value + 8;
  esize.298 = (unsigned int) esize;
  mono_gc_memmove_atomic (ea, D.31291, esize.298);
  <D.31290>:
  return;
  <D.31285>:
  D.31292 = BIT_FIELD_REF <*vc, 32, 160>;
  D.31293 = D.31292 & 8;
  if (D.31293 == 0) goto <D.31294>; else goto <D.31295>;
  <D.31294>:
  D.31296 = mono_get_runtime_callbacks ();
  D.31297 = D.31296->set_cast_details;
  D.31297 (vc, ec);
  D.31298 = mono_get_exception_invalid_cast ();
  mono_raise_exception (D.31298);
  <D.31295>:
  D.31299 = mono_class_instance_size (vc);
  D.31300 = (unsigned int) D.31299;
  D.31301 = D.31300 + 4294967288;
  vsize = (gint32) D.31301;
  D.31261 = ec->byval_arg.type;
  et = (int) D.31261;
  if (et == 17) goto <D.31302>; else goto <D.31303>;
  <D.31302>:
  D.31304 = ec->byval_arg.data.klass;
  D.31305 = BIT_FIELD_REF <*D.31304, 32, 160>;
  D.31306 = D.31305 & 16;
  if (D.31306 != 0) goto <D.31307>; else goto <D.31308>;
  <D.31307>:
  D.31304 = ec->byval_arg.data.klass;
  D.31309 = mono_class_enum_basetype (D.31304);
  D.31310 = D.31309->type;
  et = (int) D.31310;
  <D.31308>:
  <D.31303>:
  D.31263 = vc->byval_arg.type;
  vt = (int) D.31263;
  if (vt == 17) goto <D.31311>; else goto <D.31312>;
  <D.31311>:
  D.31313 = vc->byval_arg.data.klass;
  D.31314 = BIT_FIELD_REF <*D.31313, 32, 160>;
  D.31315 = D.31314 & 16;
  if (D.31315 != 0) goto <D.31316>; else goto <D.31317>;
  <D.31316>:
  D.31313 = vc->byval_arg.data.klass;
  D.31318 = mono_class_enum_basetype (D.31313);
  D.31319 = D.31318->type;
  vt = (int) D.31319;
  <D.31317>:
  <D.31312>:
  switch (vt) <default: <D.31331>, case 2: <D.20376>, case 3: <D.20375>, case 4: <D.20369>, case 5: <D.20364>, case 6: <D.20370>, case 7: <D.20366>, case 8: <D.20371>, case 9: <D.20367>, case 10: <D.20372>, case 11: <D.20368>, case 12: <D.20373>, case 13: <D.20374>>
  <D.20364>:
  D.31320 = MEM[(guint8 *)va];
  u64 = (guint64) D.31320;
  goto <D.20365>;
  <D.20366>:
  D.31321 = MEM[(guint16 *)va];
  u64 = (guint64) D.31321;
  goto <D.20365>;
  <D.20367>:
  D.31322 = MEM[(guint32 *)va];
  u64 = (guint64) D.31322;
  goto <D.20365>;
  <D.20368>:
  u64 = MEM[(guint64 *)va];
  goto <D.20365>;
  <D.20369>:
  D.31323 = MEM[(gint8 *)va];
  i64 = (gint64) D.31323;
  goto <D.20365>;
  <D.20370>:
  D.31324 = MEM[(gint16 *)va];
  i64 = (gint64) D.31324;
  goto <D.20365>;
  <D.20371>:
  D.31325 = MEM[(gint32 *)va];
  i64 = (gint64) D.31325;
  goto <D.20365>;
  <D.20372>:
  i64 = MEM[(gint64 *)va];
  goto <D.20365>;
  <D.20373>:
  D.31326 = MEM[(gfloat *)va];
  r64 = (gdouble) D.31326;
  goto <D.20365>;
  <D.20374>:
  r64 = MEM[(gdouble *)va];
  goto <D.20365>;
  <D.20375>:
  D.31321 = MEM[(guint16 *)va];
  u64 = (guint64) D.31321;
  goto <D.20365>;
  <D.20376>:
  switch (et) <default: <D.20388>, case 3: <D.20377>, case 4: <D.20382>, case 5: <D.20378>, case 6: <D.20383>, case 7: <D.20379>, case 8: <D.20384>, case 9: <D.20380>, case 10: <D.20385>, case 11: <D.20381>, case 12: <D.20386>, case 13: <D.20387>>
  <D.20377>:
  <D.20378>:
  <D.20379>:
  <D.20380>:
  <D.20381>:
  <D.20382>:
  <D.20383>:
  <D.20384>:
  <D.20385>:
  <D.20386>:
  <D.20387>:
  D.31327 = mono_get_exception_argument ("value", "not a widening conversion");
  mono_raise_exception (D.31327);
  <D.20388>:
  D.31328 = mono_get_runtime_callbacks ();
  D.31329 = D.31328->set_cast_details;
  D.31329 (vc, ec);
  D.31330 = mono_get_exception_invalid_cast ();
  mono_raise_exception (D.31330);
  goto <D.20365>;
  <D.31331>:
  <D.20365>:
  switch (et) <default: <D.31412>, case 3: <D.20389>, case 4: <D.20449>, case 5: <D.20401>, case 6: <D.20461>, case 7: <D.20413>, case 8: <D.20473>, case 9: <D.20425>, case 10: <D.20485>, case 11: <D.20437>, case 12: <D.20497>, case 13: <D.20509>>
  <D.20389>:
  switch (vt) <default: <D.31337>, case 3: <D.20394>, case 4: <D.20395>, case 5: <D.20390>, case 6: <D.20396>, case 7: <D.20391>, case 8: <D.20397>, case 9: <D.20392>, case 10: <D.20398>, case 11: <D.20393>, case 12: <D.20399>, case 13: <D.20400>>
  <D.20390>:
  <D.20391>:
  <D.20392>:
  <D.20393>:
  <D.20394>:
  if (esize < vsize) goto <D.31332>; else goto <D.31333>;
  <D.31332>:
  D.31334 = mono_get_exception_argument ("value", "not a widening conversion");
  mono_raise_exception (D.31334);
  <D.31333>:
  D.31335 = (short unsigned int) u64;
  MEM[(guint16 *)ea] = D.31335;
  return;
  <D.20395>:
  <D.20396>:
  <D.20397>:
  <D.20398>:
  <D.20399>:
  <D.20400>:
  D.31336 = mono_get_exception_argument ("value", "not a widening conversion");
  mono_raise_exception (D.31336);
  <D.31337>:
  <D.20401>:
  switch (vt) <default: <D.31343>, case 3: <D.20406>, case 4: <D.20407>, case 5: <D.20402>, case 6: <D.20408>, case 7: <D.20403>, case 8: <D.20409>, case 9: <D.20404>, case 10: <D.20410>, case 11: <D.20405>, case 12: <D.20411>, case 13: <D.20412>>
  <D.20402>:
  <D.20403>:
  <D.20404>:
  <D.20405>:
  <D.20406>:
  if (esize < vsize) goto <D.31338>; else goto <D.31339>;
  <D.31338>:
  D.31340 = mono_get_exception_argument ("value", "not a widening conversion");
  mono_raise_exception (D.31340);
  <D.31339>:
  D.31341 = (unsigned char) u64;
  MEM[(guint8 *)ea] = D.31341;
  return;
  <D.20407>:
  <D.20408>:
  <D.20409>:
  <D.20410>:
  <D.20411>:
  <D.20412>:
  D.31342 = mono_get_exception_argument ("value", "not a widening conversion");
  mono_raise_exception (D.31342);
  <D.31343>:
  <D.20413>:
  switch (vt) <default: <D.31348>, case 3: <D.20418>, case 4: <D.20419>, case 5: <D.20414>, case 6: <D.20420>, case 7: <D.20415>, case 8: <D.20421>, case 9: <D.20416>, case 10: <D.20422>, case 11: <D.20417>, case 12: <D.20423>, case 13: <D.20424>>
  <D.20414>:
  <D.20415>:
  <D.20416>:
  <D.20417>:
  <D.20418>:
  if (esize < vsize) goto <D.31344>; else goto <D.31345>;
  <D.31344>:
  D.31346 = mono_get_exception_argument ("value", "not a widening conversion");
  mono_raise_exception (D.31346);
  <D.31345>:
  D.31335 = (short unsigned int) u64;
  MEM[(guint16 *)ea] = D.31335;
  return;
  <D.20419>:
  <D.20420>:
  <D.20421>:
  <D.20422>:
  <D.20423>:
  <D.20424>:
  D.31347 = mono_get_exception_argument ("value", "not a widening conversion");
  mono_raise_exception (D.31347);
  <D.31348>:
  <D.20425>:
  switch (vt) <default: <D.31354>, case 3: <D.20430>, case 4: <D.20431>, case 5: <D.20426>, case 6: <D.20432>, case 7: <D.20427>, case 8: <D.20433>, case 9: <D.20428>, case 10: <D.20434>, case 11: <D.20429>, case 12: <D.20435>, case 13: <D.20436>>
  <D.20426>:
  <D.20427>:
  <D.20428>:
  <D.20429>:
  <D.20430>:
  if (esize < vsize) goto <D.31349>; else goto <D.31350>;
  <D.31349>:
  D.31351 = mono_get_exception_argument ("value", "not a widening conversion");
  mono_raise_exception (D.31351);
  <D.31350>:
  D.31352 = (unsigned int) u64;
  MEM[(guint32 *)ea] = D.31352;
  return;
  <D.20431>:
  <D.20432>:
  <D.20433>:
  <D.20434>:
  <D.20435>:
  <D.20436>:
  D.31353 = mono_get_exception_argument ("value", "not a widening conversion");
  mono_raise_exception (D.31353);
  <D.31354>:
  <D.20437>:
  switch (vt) <default: <D.31359>, case 3: <D.20442>, case 4: <D.20443>, case 5: <D.20438>, case 6: <D.20444>, case 7: <D.20439>, case 8: <D.20445>, case 9: <D.20440>, case 10: <D.20446>, case 11: <D.20441>, case 12: <D.20447>, case 13: <D.20448>>
  <D.20438>:
  <D.20439>:
  <D.20440>:
  <D.20441>:
  <D.20442>:
  if (esize < vsize) goto <D.31355>; else goto <D.31356>;
  <D.31355>:
  D.31357 = mono_get_exception_argument ("value", "not a widening conversion");
  mono_raise_exception (D.31357);
  <D.31356>:
  MEM[(guint64 *)ea] = u64;
  return;
  <D.20443>:
  <D.20444>:
  <D.20445>:
  <D.20446>:
  <D.20447>:
  <D.20448>:
  D.31358 = mono_get_exception_argument ("value", "not a widening conversion");
  mono_raise_exception (D.31358);
  <D.31359>:
  <D.20449>:
  switch (vt) <default: <D.31369>, case 3: <D.20458>, case 4: <D.20450>, case 5: <D.20454>, case 6: <D.20451>, case 7: <D.20455>, case 8: <D.20452>, case 9: <D.20456>, case 10: <D.20453>, case 11: <D.20457>, case 12: <D.20459>, case 13: <D.20460>>
  <D.20450>:
  <D.20451>:
  <D.20452>:
  <D.20453>:
  if (esize < vsize) goto <D.31360>; else goto <D.31361>;
  <D.31360>:
  D.31362 = mono_get_exception_argument ("value", "not a widening conversion");
  mono_raise_exception (D.31362);
  <D.31361>:
  D.31363 = (signed char) i64;
  MEM[(gint8 *)ea] = D.31363;
  return;
  <D.20454>:
  <D.20455>:
  <D.20456>:
  <D.20457>:
  <D.20458>:
  if (vsize >= esize) goto <D.31364>; else goto <D.31365>;
  <D.31364>:
  D.31366 = mono_get_exception_argument ("value", "not a widening conversion");
  mono_raise_exception (D.31366);
  <D.31365>:
  D.31367 = (signed char) u64;
  MEM[(gint8 *)ea] = D.31367;
  return;
  <D.20459>:
  <D.20460>:
  D.31368 = mono_get_exception_argument ("value", "not a widening conversion");
  mono_raise_exception (D.31368);
  <D.31369>:
  <D.20461>:
  switch (vt) <default: <D.31379>, case 3: <D.20470>, case 4: <D.20462>, case 5: <D.20466>, case 6: <D.20463>, case 7: <D.20467>, case 8: <D.20464>, case 9: <D.20468>, case 10: <D.20465>, case 11: <D.20469>, case 12: <D.20471>, case 13: <D.20472>>
  <D.20462>:
  <D.20463>:
  <D.20464>:
  <D.20465>:
  if (esize < vsize) goto <D.31370>; else goto <D.31371>;
  <D.31370>:
  D.31372 = mono_get_exception_argument ("value", "not a widening conversion");
  mono_raise_exception (D.31372);
  <D.31371>:
  D.31373 = (short int) i64;
  MEM[(gint16 *)ea] = D.31373;
  return;
  <D.20466>:
  <D.20467>:
  <D.20468>:
  <D.20469>:
  <D.20470>:
  if (vsize >= esize) goto <D.31374>; else goto <D.31375>;
  <D.31374>:
  D.31376 = mono_get_exception_argument ("value", "not a widening conversion");
  mono_raise_exception (D.31376);
  <D.31375>:
  D.31377 = (short int) u64;
  MEM[(gint16 *)ea] = D.31377;
  return;
  <D.20471>:
  <D.20472>:
  D.31378 = mono_get_exception_argument ("value", "not a widening conversion");
  mono_raise_exception (D.31378);
  <D.31379>:
  <D.20473>:
  switch (vt) <default: <D.31389>, case 3: <D.20482>, case 4: <D.20474>, case 5: <D.20478>, case 6: <D.20475>, case 7: <D.20479>, case 8: <D.20476>, case 9: <D.20480>, case 10: <D.20477>, case 11: <D.20481>, case 12: <D.20483>, case 13: <D.20484>>
  <D.20474>:
  <D.20475>:
  <D.20476>:
  <D.20477>:
  if (esize < vsize) goto <D.31380>; else goto <D.31381>;
  <D.31380>:
  D.31382 = mono_get_exception_argument ("value", "not a widening conversion");
  mono_raise_exception (D.31382);
  <D.31381>:
  D.31383 = (int) i64;
  MEM[(gint32 *)ea] = D.31383;
  return;
  <D.20478>:
  <D.20479>:
  <D.20480>:
  <D.20481>:
  <D.20482>:
  if (vsize >= esize) goto <D.31384>; else goto <D.31385>;
  <D.31384>:
  D.31386 = mono_get_exception_argument ("value", "not a widening conversion");
  mono_raise_exception (D.31386);
  <D.31385>:
  D.31387 = (int) u64;
  MEM[(gint32 *)ea] = D.31387;
  return;
  <D.20483>:
  <D.20484>:
  D.31388 = mono_get_exception_argument ("value", "not a widening conversion");
  mono_raise_exception (D.31388);
  <D.31389>:
  <D.20485>:
  switch (vt) <default: <D.31398>, case 3: <D.20494>, case 4: <D.20486>, case 5: <D.20490>, case 6: <D.20487>, case 7: <D.20491>, case 8: <D.20488>, case 9: <D.20492>, case 10: <D.20489>, case 11: <D.20493>, case 12: <D.20495>, case 13: <D.20496>>
  <D.20486>:
  <D.20487>:
  <D.20488>:
  <D.20489>:
  if (esize < vsize) goto <D.31390>; else goto <D.31391>;
  <D.31390>:
  D.31392 = mono_get_exception_argument ("value", "not a widening conversion");
  mono_raise_exception (D.31392);
  <D.31391>:
  MEM[(gint64 *)ea] = i64;
  return;
  <D.20490>:
  <D.20491>:
  <D.20492>:
  <D.20493>:
  <D.20494>:
  if (vsize >= esize) goto <D.31393>; else goto <D.31394>;
  <D.31393>:
  D.31395 = mono_get_exception_argument ("value", "not a widening conversion");
  mono_raise_exception (D.31395);
  <D.31394>:
  u64.299 = (long long int) u64;
  MEM[(gint64 *)ea] = u64.299;
  return;
  <D.20495>:
  <D.20496>:
  D.31397 = mono_get_exception_argument ("value", "not a widening conversion");
  mono_raise_exception (D.31397);
  <D.31398>:
  <D.20497>:
  switch (vt) <default: <D.31405>, case 3: <D.20508>, case 4: <D.20500>, case 5: <D.20504>, case 6: <D.20501>, case 7: <D.20505>, case 8: <D.20502>, case 9: <D.20506>, case 10: <D.20503>, case 11: <D.20507>, case 12: <D.20498>, case 13: <D.20499>>
  <D.20498>:
  <D.20499>:
  if (esize < vsize) goto <D.31399>; else goto <D.31400>;
  <D.31399>:
  D.31401 = mono_get_exception_argument ("value", "not a widening conversion");
  mono_raise_exception (D.31401);
  <D.31400>:
  D.31402 = (float) r64;
  MEM[(gfloat *)ea] = D.31402;
  return;
  <D.20500>:
  <D.20501>:
  <D.20502>:
  <D.20503>:
  D.31403 = (float) i64;
  MEM[(gfloat *)ea] = D.31403;
  return;
  <D.20504>:
  <D.20505>:
  <D.20506>:
  <D.20507>:
  <D.20508>:
  D.31404 = (float) u64;
  MEM[(gfloat *)ea] = D.31404;
  return;
  <D.31405>:
  <D.20509>:
  switch (vt) <default: <D.31411>, case 3: <D.20520>, case 4: <D.20512>, case 5: <D.20516>, case 6: <D.20513>, case 7: <D.20517>, case 8: <D.20514>, case 9: <D.20518>, case 10: <D.20515>, case 11: <D.20519>, case 12: <D.20510>, case 13: <D.20511>>
  <D.20510>:
  <D.20511>:
  if (esize < vsize) goto <D.31406>; else goto <D.31407>;
  <D.31406>:
  D.31408 = mono_get_exception_argument ("value", "not a widening conversion");
  mono_raise_exception (D.31408);
  <D.31407>:
  MEM[(gdouble *)ea] = r64;
  return;
  <D.20512>:
  <D.20513>:
  <D.20514>:
  <D.20515>:
  D.31409 = (double) i64;
  MEM[(gdouble *)ea] = D.31409;
  return;
  <D.20516>:
  <D.20517>:
  <D.20518>:
  <D.20519>:
  <D.20520>:
  D.31410 = (double) u64;
  MEM[(gdouble *)ea] = D.31410;
  return;
  <D.31411>:
  <D.31412>:
  D.31413 = mono_get_runtime_callbacks ();
  D.31414 = D.31413->set_cast_details;
  D.31414 (vc, ec);
  D.31415 = mono_get_exception_invalid_cast ();
  mono_raise_exception (D.31415);
  return;
}


ves_icall_System_Array_SetValue (struct MonoArray * this, struct MonoObject * value, struct MonoArray * idxs)
{
  _Bool D.31419;
  long int D.31420;
  long int D.31421;
  struct MonoVTable * D.31426;
  struct MonoVTable * D.31427;
  unsigned char D.31428;
  _Bool D.31429;
  long int D.31430;
  long int D.31431;
  struct MonoArrayBounds * D.31436;
  unsigned int D.31438;
  unsigned char D.31439;
  unsigned int D.31440;
  struct MonoException * D.31441;
  struct MonoArrayBounds * D.31442;
  int D.31447;
  unsigned int D.31449;
  unsigned int D.31450;
  struct MonoException * D.31451;
  unsigned int D.31452;
  unsigned int i.300;
  unsigned int D.31456;
  gint32 * D.31457;
  int D.31458;
  unsigned int D.31459;
  struct MonoArrayBounds * D.31460;
  int D.31461;
  unsigned int D.31463;
  int D.31464;
  int D.31465;
  struct MonoException * D.31466;
  int D.31467;
  int D.31468;
  unsigned int pos.301;
  unsigned int D.31470;
  unsigned int D.31471;
  unsigned int D.31472;
  unsigned int D.31473;
  unsigned int D.31474;
  unsigned int pos.302;
  struct MonoClass * ac;
  struct MonoClass * ic;
  gint32 i;
  gint32 pos;
  gint32 * ind;

  D.31419 = idxs == 0B;
  D.31420 = (long int) D.31419;
  D.31421 = __builtin_expect (D.31420, 0);
  if (D.31421 != 0) goto <D.31422>; else goto <D.31423>;
  <D.31422>:
  {
    struct MonoException * ex;

    if (idxs != 0B) goto <D.31424>; else goto <D.31425>;
    <D.31424>:
    <D.31425>:
    ex = mono_get_exception_argument_null ("idxs");
    mono_raise_exception (ex);
  }
  <D.31423>:
  D.31426 = idxs->obj.vtable;
  ic = D.31426->klass;
  D.31427 = this->obj.vtable;
  ac = D.31427->klass;
  D.31428 = ic->rank;
  D.31429 = D.31428 != 1;
  D.31430 = (long int) D.31429;
  D.31431 = __builtin_expect (D.31430, 0);
  if (D.31431 != 0) goto <D.31432>; else goto <D.31433>;
  <D.31432>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "icall.c", 502, "ic->rank == 1");
  <D.31433>:
  D.31436 = idxs->bounds;
  if (D.31436 != 0B) goto <D.31434>; else goto <D.31437>;
  <D.31437>:
  D.31438 = idxs->max_length;
  D.31439 = ac->rank;
  D.31440 = (unsigned int) D.31439;
  if (D.31438 != D.31440) goto <D.31434>; else goto <D.31435>;
  <D.31434>:
  D.31441 = mono_get_exception_argument (0B, 0B);
  mono_raise_exception (D.31441);
  <D.31435>:
  ind = &idxs->vector;
  D.31442 = this->bounds;
  if (D.31442 == 0B) goto <D.31443>; else goto <D.31444>;
  <D.31443>:
  D.31447 = *ind;
  if (D.31447 < 0) goto <D.31445>; else goto <D.31448>;
  <D.31448>:
  D.31447 = *ind;
  D.31449 = (unsigned int) D.31447;
  D.31450 = this->max_length;
  if (D.31449 >= D.31450) goto <D.31445>; else goto <D.31446>;
  <D.31445>:
  D.31451 = mono_get_exception_index_out_of_range ();
  mono_raise_exception (D.31451);
  <D.31446>:
  D.31447 = *ind;
  D.31452 = (unsigned int) D.31447;
  ves_icall_System_Array_SetValueImpl (this, value, D.31452);
  return;
  <D.31444>:
  i = 0;
  goto <D.20533>;
  <D.20532>:
  i.300 = (unsigned int) i;
  D.31456 = i.300 * 4;
  D.31457 = ind + D.31456;
  D.31458 = *D.31457;
  D.31442 = this->bounds;
  i.300 = (unsigned int) i;
  D.31459 = i.300 * 8;
  D.31460 = D.31442 + D.31459;
  D.31461 = D.31460->lower_bound;
  if (D.31458 < D.31461) goto <D.31453>; else goto <D.31462>;
  <D.31462>:
  i.300 = (unsigned int) i;
  D.31456 = i.300 * 4;
  D.31457 = ind + D.31456;
  D.31458 = *D.31457;
  D.31442 = this->bounds;
  i.300 = (unsigned int) i;
  D.31459 = i.300 * 8;
  D.31460 = D.31442 + D.31459;
  D.31463 = D.31460->length;
  D.31464 = (int) D.31463;
  D.31442 = this->bounds;
  i.300 = (unsigned int) i;
  D.31459 = i.300 * 8;
  D.31460 = D.31442 + D.31459;
  D.31461 = D.31460->lower_bound;
  D.31465 = D.31464 + D.31461;
  if (D.31458 >= D.31465) goto <D.31453>; else goto <D.31454>;
  <D.31453>:
  D.31466 = mono_get_exception_index_out_of_range ();
  mono_raise_exception (D.31466);
  <D.31454>:
  i = i + 1;
  <D.20533>:
  D.31439 = ac->rank;
  D.31467 = (int) D.31439;
  if (D.31467 > i) goto <D.20532>; else goto <D.20534>;
  <D.20534>:
  D.31447 = *ind;
  D.31442 = this->bounds;
  D.31468 = D.31442->lower_bound;
  pos = D.31447 - D.31468;
  i = 1;
  goto <D.20536>;
  <D.20535>:
  D.31442 = this->bounds;
  i.300 = (unsigned int) i;
  D.31459 = i.300 * 8;
  D.31460 = D.31442 + D.31459;
  D.31463 = D.31460->length;
  pos.301 = (unsigned int) pos;
  D.31470 = D.31463 * pos.301;
  i.300 = (unsigned int) i;
  D.31456 = i.300 * 4;
  D.31457 = ind + D.31456;
  D.31458 = *D.31457;
  D.31471 = (unsigned int) D.31458;
  D.31472 = D.31470 + D.31471;
  D.31442 = this->bounds;
  i.300 = (unsigned int) i;
  D.31459 = i.300 * 8;
  D.31460 = D.31442 + D.31459;
  D.31461 = D.31460->lower_bound;
  D.31473 = (unsigned int) D.31461;
  D.31474 = D.31472 - D.31473;
  pos = (gint32) D.31474;
  i = i + 1;
  <D.20536>:
  D.31439 = ac->rank;
  D.31467 = (int) D.31439;
  if (D.31467 > i) goto <D.20535>; else goto <D.20537>;
  <D.20537>:
  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.31477;
  double[0:] * D.31478;
  unsigned int esize.303;
  unsigned int D.31480;
  struct MonoType * D.31481;
  int D.31482;
  _Bool D.31485;
  long int D.31486;
  long int D.31487;
  void * D.31490;
  unsigned int D.31492;
  unsigned int D.31493;
  _Bool D.31494;
  long int D.31495;
  long int D.31496;
  int D.31499;
  _Bool D.31500;
  long int D.31501;
  long int D.31502;
  unsigned int D.31505;
  unsigned int esize.304;
  struct MonoClass * ac;
  struct MonoClass * ec;
  struct MonoArray * ao;
  gint32 esize;
  void * * ea;

  ao = this;
  D.31477 = ao->obj.vtable;
  ac = D.31477->klass;
  ec = ac->element_class;
  esize = mono_array_element_size (ac);
  D.31478 = &ao->vector;
  esize.303 = (unsigned int) esize;
  D.31480 = pos * esize.303;
  ea = D.31478 + D.31480;
  D.31481 = &ec->byval_arg;
  D.31482 = mono_type_is_reference (D.31481);
  if (D.31482 != 0) goto <D.31483>; else goto <D.31484>;
  <D.31483>:
  D.31485 = esize != 4;
  D.31486 = (long int) D.31485;
  D.31487 = __builtin_expect (D.31486, 0);
  if (D.31487 != 0) goto <D.31488>; else goto <D.31489>;
  <D.31488>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "icall.c", 793, "esize == sizeof (gpointer)");
  <D.31489>:
  D.31490 = MEM[(void * *)value];
  mono_gc_wbarrier_generic_store (ea, D.31490);
  goto <D.31491>;
  <D.31484>:
  D.31492 = BIT_FIELD_REF <*ec, 32, 160>;
  D.31493 = D.31492 & 1;
  D.31494 = D.31493 == 0;
  D.31495 = (long int) D.31494;
  D.31496 = __builtin_expect (D.31495, 0);
  if (D.31496 != 0) goto <D.31497>; else goto <D.31498>;
  <D.31497>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "icall.c", 796, "ec->inited");
  <D.31498>:
  D.31499 = mono_class_value_size (ec, 0B);
  D.31500 = D.31499 != esize;
  D.31501 = (long int) D.31500;
  D.31502 = __builtin_expect (D.31501, 0);
  if (D.31502 != 0) goto <D.31503>; else goto <D.31504>;
  <D.31503>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "icall.c", 797, "esize == mono_class_value_size (ec, NULL)");
  <D.31504>:
  D.31492 = BIT_FIELD_REF <*ec, 32, 160>;
  D.31505 = D.31492 & 134217728;
  if (D.31505 != 0) goto <D.31506>; else goto <D.31507>;
  <D.31506>:
  mono_gc_wbarrier_value_copy (ea, value, 1, ec);
  goto <D.31508>;
  <D.31507>:
  esize.304 = (unsigned int) esize;
  mono_gc_memmove_atomic (ea, value, esize.304);
  <D.31508>:
  <D.31491>:
}


ves_icall_System_Array_GetValueImpl (struct MonoObject * this, guint32 pos)
{
  struct MonoVTable * D.31510;
  double[0:] * D.31511;
  unsigned int esize.305;
  unsigned int D.31513;
  struct MonoClass * D.31514;
  unsigned int D.31515;
  unsigned int D.31516;
  struct MonoObject * D.31519;
  struct MonoVTable * D.31520;
  struct MonoDomain * D.31521;
  struct MonoClass * ac;
  struct MonoArray * ao;
  gint32 esize;
  void * * ea;

  ao = this;
  D.31510 = ao->obj.vtable;
  ac = D.31510->klass;
  esize = mono_array_element_size (ac);
  D.31511 = &ao->vector;
  esize.305 = (unsigned int) esize;
  D.31513 = pos * esize.305;
  ea = D.31511 + D.31513;
  D.31514 = ac->element_class;
  D.31515 = BIT_FIELD_REF <*D.31514, 32, 160>;
  D.31516 = D.31515 & 8;
  if (D.31516 != 0) goto <D.31517>; else goto <D.31518>;
  <D.31517>:
  D.31520 = this->vtable;
  D.31521 = D.31520->domain;
  D.31514 = ac->element_class;
  D.31519 = mono_value_box (D.31521, D.31514, ea);
  return D.31519;
  <D.31518>:
  D.31519 = *ea;
  return D.31519;
}


ves_icall_System_Array_GetValue (struct MonoObject * this, struct MonoObject * idxs)
{
  _Bool D.31523;
  long int D.31524;
  long int D.31525;
  struct MonoVTable * D.31530;
  struct MonoVTable * D.31531;
  unsigned char D.31532;
  _Bool D.31533;
  long int D.31534;
  long int D.31535;
  struct MonoArrayBounds * D.31540;
  unsigned int D.31542;
  unsigned char D.31543;
  unsigned int D.31544;
  struct MonoException * D.31545;
  struct MonoArrayBounds * D.31546;
  int D.31551;
  unsigned int D.31553;
  unsigned int D.31554;
  struct MonoException * D.31555;
  struct MonoObject * D.31556;
  unsigned int D.31557;
  unsigned int i.306;
  unsigned int D.31561;
  gint32 * D.31562;
  int D.31563;
  unsigned int D.31564;
  struct MonoArrayBounds * D.31565;
  int D.31566;
  unsigned int D.31568;
  int D.31569;
  int D.31570;
  struct MonoException * D.31571;
  int D.31572;
  int D.31573;
  unsigned int pos.307;
  unsigned int D.31575;
  unsigned int D.31576;
  unsigned int D.31577;
  unsigned int D.31578;
  unsigned int D.31579;
  unsigned int pos.308;
  struct MonoClass * ac;
  struct MonoClass * ic;
  struct MonoArray * ao;
  struct MonoArray * io;
  gint32 i;
  gint32 pos;
  gint32 * ind;

  D.31523 = idxs == 0B;
  D.31524 = (long int) D.31523;
  D.31525 = __builtin_expect (D.31524, 0);
  if (D.31525 != 0) goto <D.31526>; else goto <D.31527>;
  <D.31526>:
  {
    struct MonoException * ex;

    if (idxs != 0B) goto <D.31528>; else goto <D.31529>;
    <D.31528>:
    <D.31529>:
    ex = mono_get_exception_argument_null ("idxs");
    mono_raise_exception (ex);
  }
  <D.31527>:
  io = idxs;
  D.31530 = io->obj.vtable;
  ic = D.31530->klass;
  ao = this;
  D.31531 = ao->obj.vtable;
  ac = D.31531->klass;
  D.31532 = ic->rank;
  D.31533 = D.31532 != 1;
  D.31534 = (long int) D.31533;
  D.31535 = __builtin_expect (D.31534, 0);
  if (D.31535 != 0) goto <D.31536>; else goto <D.31537>;
  <D.31536>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "icall.c", 184, "ic->rank == 1");
  <D.31537>:
  D.31540 = io->bounds;
  if (D.31540 != 0B) goto <D.31538>; else goto <D.31541>;
  <D.31541>:
  D.31542 = io->max_length;
  D.31543 = ac->rank;
  D.31544 = (unsigned int) D.31543;
  if (D.31542 != D.31544) goto <D.31538>; else goto <D.31539>;
  <D.31538>:
  D.31545 = mono_get_exception_argument (0B, 0B);
  mono_raise_exception (D.31545);
  <D.31539>:
  ind = &io->vector;
  D.31546 = ao->bounds;
  if (D.31546 == 0B) goto <D.31547>; else goto <D.31548>;
  <D.31547>:
  D.31551 = *ind;
  if (D.31551 < 0) goto <D.31549>; else goto <D.31552>;
  <D.31552>:
  D.31551 = *ind;
  D.31553 = (unsigned int) D.31551;
  D.31554 = ao->max_length;
  if (D.31553 >= D.31554) goto <D.31549>; else goto <D.31550>;
  <D.31549>:
  D.31555 = mono_get_exception_index_out_of_range ();
  mono_raise_exception (D.31555);
  <D.31550>:
  D.31551 = *ind;
  D.31557 = (unsigned int) D.31551;
  D.31556 = ves_icall_System_Array_GetValueImpl (this, D.31557);
  return D.31556;
  <D.31548>:
  i = 0;
  goto <D.20322>;
  <D.20321>:
  i.306 = (unsigned int) i;
  D.31561 = i.306 * 4;
  D.31562 = ind + D.31561;
  D.31563 = *D.31562;
  D.31546 = ao->bounds;
  i.306 = (unsigned int) i;
  D.31564 = i.306 * 8;
  D.31565 = D.31546 + D.31564;
  D.31566 = D.31565->lower_bound;
  if (D.31563 < D.31566) goto <D.31558>; else goto <D.31567>;
  <D.31567>:
  i.306 = (unsigned int) i;
  D.31561 = i.306 * 4;
  D.31562 = ind + D.31561;
  D.31563 = *D.31562;
  D.31546 = ao->bounds;
  i.306 = (unsigned int) i;
  D.31564 = i.306 * 8;
  D.31565 = D.31546 + D.31564;
  D.31568 = D.31565->length;
  D.31569 = (int) D.31568;
  D.31546 = ao->bounds;
  i.306 = (unsigned int) i;
  D.31564 = i.306 * 8;
  D.31565 = D.31546 + D.31564;
  D.31566 = D.31565->lower_bound;
  D.31570 = D.31569 + D.31566;
  if (D.31563 >= D.31570) goto <D.31558>; else goto <D.31559>;
  <D.31558>:
  D.31571 = mono_get_exception_index_out_of_range ();
  mono_raise_exception (D.31571);
  <D.31559>:
  i = i + 1;
  <D.20322>:
  D.31543 = ac->rank;
  D.31572 = (int) D.31543;
  if (D.31572 > i) goto <D.20321>; else goto <D.20323>;
  <D.20323>:
  D.31551 = *ind;
  D.31546 = ao->bounds;
  D.31573 = D.31546->lower_bound;
  pos = D.31551 - D.31573;
  i = 1;
  goto <D.20325>;
  <D.20324>:
  D.31546 = ao->bounds;
  i.306 = (unsigned int) i;
  D.31564 = i.306 * 8;
  D.31565 = D.31546 + D.31564;
  D.31568 = D.31565->length;
  pos.307 = (unsigned int) pos;
  D.31575 = D.31568 * pos.307;
  i.306 = (unsigned int) i;
  D.31561 = i.306 * 4;
  D.31562 = ind + D.31561;
  D.31563 = *D.31562;
  D.31576 = (unsigned int) D.31563;
  D.31577 = D.31575 + D.31576;
  D.31546 = ao->bounds;
  i.306 = (unsigned int) i;
  D.31564 = i.306 * 8;
  D.31565 = D.31546 + D.31564;
  D.31566 = D.31565->lower_bound;
  D.31578 = (unsigned int) D.31566;
  D.31579 = D.31577 - D.31578;
  pos = (gint32) D.31579;
  i = i + 1;
  <D.20325>:
  D.31543 = ac->rank;
  D.31572 = (int) D.31543;
  if (D.31572 > i) goto <D.20324>; else goto <D.20326>;
  <D.20326>:
  pos.308 = (unsigned int) pos;
  D.31556 = ves_icall_System_Array_GetValueImpl (this, pos.308);
  return D.31556;
}


ves_icall_System_Array_GetRank (struct MonoObject * this)
{
  gint32 D.31582;
  struct MonoVTable * D.31583;
  struct MonoClass * D.31584;
  unsigned char D.31585;

  D.31583 = this->vtable;
  D.31584 = D.31583->klass;
  D.31585 = D.31584->rank;
  D.31582 = (gint32) D.31585;
  return D.31582;
}


ves_icall_System_Array_GetLowerBound (struct MonoArray * this, gint32 dimension)
{
  struct MonoVTable * D.31587;
  struct MonoClass * D.31588;
  unsigned char D.31589;
  struct MonoException * D.31593;
  struct MonoArrayBounds * D.31594;
  gint32 D.31597;
  unsigned int dimension.309;
  unsigned int D.31599;
  struct MonoArrayBounds * D.31600;
  gint32 rank;

  D.31587 = MEM[(struct MonoObject *)this].vtable;
  D.31588 = D.31587->klass;
  D.31589 = D.31588->rank;
  rank = (gint32) D.31589;
  if (dimension < 0) goto <D.31590>; else goto <D.31592>;
  <D.31592>:
  if (dimension >= rank) goto <D.31590>; else goto <D.31591>;
  <D.31590>:
  D.31593 = mono_get_exception_index_out_of_range ();
  mono_raise_exception (D.31593);
  <D.31591>:
  D.31594 = this->bounds;
  if (D.31594 == 0B) goto <D.31595>; else goto <D.31596>;
  <D.31595>:
  D.31597 = 0;
  return D.31597;
  <D.31596>:
  D.31594 = this->bounds;
  dimension.309 = (unsigned int) dimension;
  D.31599 = dimension.309 * 8;
  D.31600 = D.31594 + D.31599;
  D.31597 = D.31600->lower_bound;
  return D.31597;
}


ves_icall_System_Array_GetLongLength (struct MonoArray * this, gint32 dimension)
{
  struct MonoVTable * D.31602;
  struct MonoClass * D.31603;
  unsigned char D.31604;
  struct MonoException * D.31608;
  struct MonoArrayBounds * D.31609;
  gint64 D.31612;
  unsigned int D.31613;
  unsigned int dimension.310;
  unsigned int D.31615;
  struct MonoArrayBounds * D.31616;
  unsigned int D.31617;
  gint32 rank;

  D.31602 = MEM[(struct MonoObject *)this].vtable;
  D.31603 = D.31602->klass;
  D.31604 = D.31603->rank;
  rank = (gint32) D.31604;
  if (dimension < 0) goto <D.31605>; else goto <D.31607>;
  <D.31607>:
  if (dimension >= rank) goto <D.31605>; else goto <D.31606>;
  <D.31605>:
  D.31608 = mono_get_exception_index_out_of_range ();
  mono_raise_exception (D.31608);
  <D.31606>:
  D.31609 = this->bounds;
  if (D.31609 == 0B) goto <D.31610>; else goto <D.31611>;
  <D.31610>:
  D.31613 = this->max_length;
  D.31612 = (gint64) D.31613;
  return D.31612;
  <D.31611>:
  D.31609 = this->bounds;
  dimension.310 = (unsigned int) dimension;
  D.31615 = dimension.310 * 8;
  D.31616 = D.31609 + D.31615;
  D.31617 = D.31616->length;
  D.31612 = (gint64) D.31617;
  return D.31612;
}


ves_icall_System_Array_GetLength (struct MonoArray * this, gint32 dimension)
{
  struct MonoVTable * D.31619;
  struct MonoClass * D.31620;
  unsigned char D.31621;
  struct MonoException * D.31625;
  struct MonoArrayBounds * D.31626;
  unsigned int dimension.311;
  unsigned int D.31631;
  struct MonoArrayBounds * D.31632;
  gint32 D.31633;
  gint32 rank;
  uintptr_t length;

  D.31619 = MEM[(struct MonoObject *)this].vtable;
  D.31620 = D.31619->klass;
  D.31621 = D.31620->rank;
  rank = (gint32) D.31621;
  if (dimension < 0) goto <D.31622>; else goto <D.31624>;
  <D.31624>:
  if (dimension >= rank) goto <D.31622>; else goto <D.31623>;
  <D.31622>:
  D.31625 = mono_get_exception_index_out_of_range ();
  mono_raise_exception (D.31625);
  <D.31623>:
  D.31626 = this->bounds;
  if (D.31626 == 0B) goto <D.31627>; else goto <D.31628>;
  <D.31627>:
  length = this->max_length;
  goto <D.31629>;
  <D.31628>:
  D.31626 = this->bounds;
  dimension.311 = (unsigned int) dimension;
  D.31631 = dimension.311 * 8;
  D.31632 = D.31626 + D.31631;
  length = D.31632->length;
  <D.31629>:
  D.31633 = (gint32) length;
  return D.31633;
}


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

  ao = this;
  D.31635 = ao->obj.vtable;
  ac = D.31635->klass;
  esize = mono_array_element_size (ac);
  D.31636 = &ao->vector;
  esize.312 = (unsigned int) esize;
  D.31638 = pos * esize.312;
  ea = D.31636 + D.31638;
  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.31640;
  unsigned char D.31641;
  gboolean D.31644;
  struct MonoArrayBounds * D.31647;
  struct MonoArrayBounds * D.31649;
  int D.31652;
  unsigned int D.31653;
  unsigned int D.31654;
  int D.31656;
  unsigned int D.31657;
  unsigned int D.31658;
  struct MonoClass * D.31659;
  struct MonoClass * D.31660;
  struct MonoClass * D.31661;
  unsigned int D.31664;
  unsigned int D.31665;
  unsigned int D.31672;
  unsigned int D.31674;
  unsigned int D.31675;
  int D.31676;
  struct MonoVTable * D.31681;
  struct MonoClass * D.31682;
  double[0:] * D.31683;
  int D.31684;
  sizetype D.31685;
  unsigned int D.31686;
  double[0:] * D.31690;
  int D.31691;
  sizetype D.31692;
  int D.31693;
  unsigned int D.31694;
  unsigned int dest_idx.314;
  unsigned int D.31697;
  unsigned int source_idx.315;
  unsigned int D.31699;
  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.31640 = src_vtable->rank;
  D.31641 = dest_vtable->rank;
  if (D.31640 != D.31641) goto <D.31642>; else goto <D.31643>;
  <D.31642>:
  D.31644 = 0;
  return D.31644;
  <D.31643>:
  D.31647 = source->bounds;
  if (D.31647 != 0B) goto <D.31645>; else goto <D.31648>;
  <D.31648>:
  D.31649 = dest->bounds;
  if (D.31649 != 0B) goto <D.31645>; else goto <D.31646>;
  <D.31645>:
  D.31644 = 0;
  return D.31644;
  <D.31646>:
  D.31652 = dest_idx + length;
  D.31653 = (unsigned int) D.31652;
  D.31654 = dest->max_length;
  if (D.31653 > D.31654) goto <D.31650>; else goto <D.31655>;
  <D.31655>:
  D.31656 = source_idx + length;
  D.31657 = (unsigned int) D.31656;
  D.31658 = source->max_length;
  if (D.31657 > D.31658) goto <D.31650>; else goto <D.31651>;
  <D.31650>:
  D.31644 = 0;
  return D.31644;
  <D.31651>:
  D.31659 = src_vtable->klass;
  src_class = D.31659->element_class;
  D.31660 = dest_vtable->klass;
  dest_class = D.31660->element_class;
  D.31661 = mono_defaults.object_class;
  if (D.31661 == src_class) goto <D.31662>; else goto <D.31663>;
  <D.31662>:
  D.31664 = BIT_FIELD_REF <*dest_class, 32, 160>;
  D.31665 = D.31664 & 8;
  if (D.31665 != 0) goto <D.31666>; else goto <D.31667>;
  <D.31666>:
  D.31644 = 0;
  return D.31644;
  <D.31667>:
  <D.31663>:
  if (src_class != dest_class) goto <D.31668>; else goto <D.31669>;
  <D.31668>:
  D.31664 = BIT_FIELD_REF <*dest_class, 32, 160>;
  D.31672 = D.31664 & 24;
  if (D.31672 != 0) goto <D.31670>; else goto <D.31673>;
  <D.31673>:
  D.31674 = BIT_FIELD_REF <*src_class, 32, 160>;
  D.31675 = D.31674 & 24;
  if (D.31675 != 0) goto <D.31670>; else goto <D.31671>;
  <D.31670>:
  D.31644 = 0;
  return D.31644;
  <D.31671>:
  D.31676 = mono_class_is_subclass_of (src_class, dest_class, 0);
  if (D.31676 == 0) goto <D.31677>; else goto <D.31678>;
  <D.31677>:
  D.31644 = 0;
  return D.31644;
  <D.31678>:
  <D.31669>:
  D.31664 = BIT_FIELD_REF <*dest_class, 32, 160>;
  D.31665 = D.31664 & 8;
  if (D.31665 != 0) goto <D.31679>; else goto <D.31680>;
  <D.31679>:
  D.31681 = source->obj.vtable;
  D.31682 = D.31681->klass;
  element_size = mono_array_element_size (D.31682);
  D.31683 = &source->vector;
  D.31684 = element_size * source_idx;
  D.31685 = (sizetype) D.31684;
  source_addr = D.31683 + D.31685;
  D.31664 = BIT_FIELD_REF <*dest_class, 32, 160>;
  D.31686 = D.31664 & 134217728;
  if (D.31686 != 0) goto <D.31687>; else goto <D.31688>;
  <D.31687>:
  mono_value_copy_array (dest, dest_idx, source_addr, length);
  goto <D.31689>;
  <D.31688>:
  D.31690 = &dest->vector;
  D.31691 = element_size * dest_idx;
  D.31692 = (sizetype) D.31691;
  dest_addr = D.31690 + D.31692;
  D.31693 = element_size * length;
  D.31694 = (unsigned int) D.31693;
  mono_gc_memmove_atomic (dest_addr, source_addr, D.31694);
  <D.31689>:
  goto <D.31695>;
  <D.31680>:
  {
    void * * __p;
    void * * __s;

    D.31690 = &dest->vector;
    dest_idx.314 = (unsigned int) dest_idx;
    D.31697 = dest_idx.314 * 4;
    __p = D.31690 + D.31697;
    D.31683 = &source->vector;
    source_idx.315 = (unsigned int) source_idx;
    D.31699 = source_idx.315 * 4;
    __s = D.31683 + D.31699;
    mono_gc_wbarrier_arrayref_copy (__p, __s, length);
  }
  <D.31695>:
  D.31644 = 1;
  return D.31644;
}


ves_icall_System_Array_CreateInstanceImpl64 (struct MonoReflectionType * type, struct MonoArray * lengths, struct MonoArray * bounds)
{
  _Bool D.31701;
  long int D.31702;
  long int D.31703;
  _Bool D.31708;
  long int D.31709;
  long int D.31710;
  unsigned int D.31715;
  _Bool D.31716;
  long int D.31717;
  long int D.31718;
  unsigned int D.31725;
  unsigned int D.31726;
  _Bool D.31727;
  long int D.31728;
  long int D.31729;
  char * D.31736;
  long long int D.31737;
  char * D.31739;
  long long int D.31740;
  struct MonoException * D.31741;
  unsigned int D.31742;
  struct MonoType * D.31743;
  unsigned int D.31747;
  char * D.31749;
  long long int D.31750;
  unsigned int D.31752;
  unsigned char D.31753;
  unsigned int D.31754;
  unsigned int D.31755;
  unsigned int D.31756;
  uintptr_t * D.31757;
  char * D.31758;
  long long unsigned int D.31759;
  unsigned int D.31760;
  unsigned int D.31763;
  unsigned int D.31764;
  unsigned int D.31765;
  uintptr_t * D.31766;
  char * D.31767;
  long long unsigned int D.31768;
  unsigned int D.31769;
  struct MonoVTable * D.31771;
  struct MonoDomain * D.31772;
  unsigned int D.31773;
  intptr_t * D.31774;
  struct MonoArray * D.31775;
  struct MonoClass * aklass;
  struct MonoClass * klass;
  struct MonoArray * array;
  uintptr_t * sizes;
  uintptr_t i;
  gboolean bounded;

  bounded = 0;
  D.31701 = type == 0B;
  D.31702 = (long int) D.31701;
  D.31703 = __builtin_expect (D.31702, 0);
  if (D.31703 != 0) goto <D.31704>; else goto <D.31705>;
  <D.31704>:
  {
    struct MonoException * ex;

    if (type != 0B) goto <D.31706>; else goto <D.31707>;
    <D.31706>:
    <D.31707>:
    ex = mono_get_exception_argument_null ("type");
    mono_raise_exception (ex);
  }
  <D.31705>:
  D.31708 = lengths == 0B;
  D.31709 = (long int) D.31708;
  D.31710 = __builtin_expect (D.31709, 0);
  if (D.31710 != 0) goto <D.31711>; else goto <D.31712>;
  <D.31711>:
  {
    struct MonoException * ex;

    if (lengths != 0B) goto <D.31713>; else goto <D.31714>;
    <D.31713>:
    <D.31714>:
    ex = mono_get_exception_argument_null ("lengths");
    mono_raise_exception (ex);
  }
  <D.31712>:
  D.31715 = mono_array_length (lengths);
  D.31716 = D.31715 == 0;
  D.31717 = (long int) D.31716;
  D.31718 = __builtin_expect (D.31717, 0);
  if (D.31718 != 0) goto <D.31719>; else goto <D.31720>;
  <D.31719>:
  {
    struct MonoException * ex;
    char * msg;

    msg = monoeg_g_strdup_printf ("assertion `%s\' failed", "mono_array_length (lengths) > 0");
    if (lengths != 0B) goto <D.31721>; else goto <D.31722>;
    <D.31721>:
    <D.31722>:
    ex = mono_get_exception_argument ("lengths", msg);
    monoeg_g_free (msg);
    mono_raise_exception (ex);
  }
  <D.31720>:
  if (bounds != 0B) goto <D.31723>; else goto <D.31724>;
  <D.31723>:
  D.31725 = mono_array_length (lengths);
  D.31726 = mono_array_length (bounds);
  D.31727 = D.31725 != D.31726;
  D.31728 = (long int) D.31727;
  D.31729 = __builtin_expect (D.31728, 0);
  if (D.31729 != 0) goto <D.31730>; else goto <D.31731>;
  <D.31730>:
  {
    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.31732>; else goto <D.31733>;
    <D.31732>:
    <D.31733>:
    ex = mono_get_exception_argument ("bounds", msg);
    monoeg_g_free (msg);
    mono_raise_exception (ex);
  }
  <D.31731>:
  <D.31724>:
  i = 0;
  goto <D.20579>;
  <D.20578>:
  D.31736 = mono_array_addr_with_size (lengths, 8, i);
  D.31737 = MEM[(gint64 *)D.31736];
  if (D.31737 < 0) goto <D.31734>; else goto <D.31738>;
  <D.31738>:
  D.31739 = mono_array_addr_with_size (lengths, 8, i);
  D.31740 = MEM[(gint64 *)D.31739];
  if (D.31740 > 2147483647) goto <D.31734>; else goto <D.31735>;
  <D.31734>:
  D.31741 = mono_get_exception_argument_out_of_range (0B);
  mono_raise_exception (D.31741);
  <D.31735>:
  i = i + 1;
  <D.20579>:
  D.31742 = mono_array_length (lengths);
  if (D.31742 > i) goto <D.20578>; else goto <D.20580>;
  <D.20580>:
  D.31743 = type->type;
  klass = mono_class_from_mono_type (D.31743);
  mono_class_init_or_throw (klass);
  if (bounds != 0B) goto <D.31746>; else goto <D.31744>;
  <D.31746>:
  D.31747 = mono_array_length (bounds);
  if (D.31747 == 1) goto <D.31748>; else goto <D.31744>;
  <D.31748>:
  D.31749 = mono_array_addr_with_size (bounds, 8, 0);
  D.31750 = MEM[(gint64 *)D.31749];
  if (D.31750 != 0) goto <D.31751>; else goto <D.31744>;
  <D.31751>:
  bounded = 1;
  goto <D.31745>;
  <D.31744>:
  bounded = 0;
  <D.31745>:
  D.31752 = mono_array_length (lengths);
  aklass = mono_bounded_array_class_get (klass, D.31752, bounded);
  D.31753 = aklass->rank;
  D.31754 = (unsigned int) D.31753;
  D.31755 = D.31754 * 8;
  sizes = __builtin_alloca (D.31755);
  i = 0;
  goto <D.20582>;
  <D.20581>:
  D.31756 = i * 4;
  D.31757 = sizes + D.31756;
  D.31758 = mono_array_addr_with_size (lengths, 8, i);
  D.31759 = MEM[(guint64 *)D.31758];
  D.31760 = (unsigned int) D.31759;
  *D.31757 = D.31760;
  if (bounds != 0B) goto <D.31761>; else goto <D.31762>;
  <D.31761>:
  D.31753 = aklass->rank;
  D.31763 = (unsigned int) D.31753;
  D.31764 = D.31763 + i;
  D.31765 = D.31764 * 4;
  D.31766 = sizes + D.31765;
  D.31767 = mono_array_addr_with_size (bounds, 8, i);
  D.31768 = MEM[(guint64 *)D.31767];
  D.31769 = (unsigned int) D.31768;
  *D.31766 = D.31769;
  goto <D.31770>;
  <D.31762>:
  D.31753 = aklass->rank;
  D.31763 = (unsigned int) D.31753;
  D.31764 = D.31763 + i;
  D.31765 = D.31764 * 4;
  D.31766 = sizes + D.31765;
  *D.31766 = 0;
  <D.31770>:
  i = i + 1;
  <D.20582>:
  D.31753 = aklass->rank;
  D.31763 = (unsigned int) D.31753;
  if (D.31763 > i) goto <D.20581>; else goto <D.20583>;
  <D.20583>:
  D.31771 = MEM[(struct MonoObject *)type].vtable;
  D.31772 = D.31771->domain;
  D.31753 = aklass->rank;
  D.31754 = (unsigned int) D.31753;
  D.31773 = D.31754 * 4;
  D.31774 = sizes + D.31773;
  array = mono_array_new_full (D.31772, aklass, sizes, D.31774);
  D.31775 = array;
  return D.31775;
}


ves_icall_System_Array_CreateInstanceImpl (struct MonoReflectionType * type, struct MonoArray * lengths, struct MonoArray * bounds)
{
  _Bool D.31777;
  long int D.31778;
  long int D.31779;
  _Bool D.31784;
  long int D.31785;
  long int D.31786;
  unsigned int D.31791;
  _Bool D.31792;
  long int D.31793;
  long int D.31794;
  unsigned int D.31801;
  unsigned int D.31802;
  _Bool D.31803;
  long int D.31804;
  long int D.31805;
  char * D.31810;
  int D.31811;
  struct MonoException * D.31814;
  unsigned int D.31815;
  struct MonoType * D.31816;
  unsigned int D.31820;
  char * D.31822;
  int D.31823;
  unsigned int D.31825;
  unsigned char D.31826;
  unsigned int D.31827;
  unsigned int D.31828;
  unsigned int D.31829;
  uintptr_t * D.31830;
  char * D.31831;
  unsigned int D.31832;
  unsigned int D.31835;
  unsigned int D.31836;
  unsigned int D.31837;
  uintptr_t * D.31838;
  char * D.31839;
  int D.31840;
  unsigned int D.31841;
  struct MonoVTable * D.31843;
  struct MonoDomain * D.31844;
  unsigned int D.31845;
  intptr_t * D.31846;
  struct MonoArray * D.31847;
  struct MonoClass * aklass;
  struct MonoClass * klass;
  struct MonoArray * array;
  uintptr_t * sizes;
  uintptr_t i;
  gboolean bounded;

  bounded = 0;
  D.31777 = type == 0B;
  D.31778 = (long int) D.31777;
  D.31779 = __builtin_expect (D.31778, 0);
  if (D.31779 != 0) goto <D.31780>; else goto <D.31781>;
  <D.31780>:
  {
    struct MonoException * ex;

    if (type != 0B) goto <D.31782>; else goto <D.31783>;
    <D.31782>:
    <D.31783>:
    ex = mono_get_exception_argument_null ("type");
    mono_raise_exception (ex);
  }
  <D.31781>:
  D.31784 = lengths == 0B;
  D.31785 = (long int) D.31784;
  D.31786 = __builtin_expect (D.31785, 0);
  if (D.31786 != 0) goto <D.31787>; else goto <D.31788>;
  <D.31787>:
  {
    struct MonoException * ex;

    if (lengths != 0B) goto <D.31789>; else goto <D.31790>;
    <D.31789>:
    <D.31790>:
    ex = mono_get_exception_argument_null ("lengths");
    mono_raise_exception (ex);
  }
  <D.31788>:
  D.31791 = mono_array_length (lengths);
  D.31792 = D.31791 == 0;
  D.31793 = (long int) D.31792;
  D.31794 = __builtin_expect (D.31793, 0);
  if (D.31794 != 0) goto <D.31795>; else goto <D.31796>;
  <D.31795>:
  {
    struct MonoException * ex;
    char * msg;

    msg = monoeg_g_strdup_printf ("assertion `%s\' failed", "mono_array_length (lengths) > 0");
    if (lengths != 0B) goto <D.31797>; else goto <D.31798>;
    <D.31797>:
    <D.31798>:
    ex = mono_get_exception_argument ("lengths", msg);
    monoeg_g_free (msg);
    mono_raise_exception (ex);
  }
  <D.31796>:
  if (bounds != 0B) goto <D.31799>; else goto <D.31800>;
  <D.31799>:
  D.31801 = mono_array_length (lengths);
  D.31802 = mono_array_length (bounds);
  D.31803 = D.31801 != D.31802;
  D.31804 = (long int) D.31803;
  D.31805 = __builtin_expect (D.31804, 0);
  if (D.31805 != 0) goto <D.31806>; else goto <D.31807>;
  <D.31806>:
  {
    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.31808>; else goto <D.31809>;
    <D.31808>:
    <D.31809>:
    ex = mono_get_exception_argument ("bounds", msg);
    monoeg_g_free (msg);
    mono_raise_exception (ex);
  }
  <D.31807>:
  <D.31800>:
  i = 0;
  goto <D.20556>;
  <D.20555>:
  D.31810 = mono_array_addr_with_size (lengths, 4, i);
  D.31811 = MEM[(gint32 *)D.31810];
  if (D.31811 < 0) goto <D.31812>; else goto <D.31813>;
  <D.31812>:
  D.31814 = mono_get_exception_argument_out_of_range (0B);
  mono_raise_exception (D.31814);
  <D.31813>:
  i = i + 1;
  <D.20556>:
  D.31815 = mono_array_length (lengths);
  if (D.31815 > i) goto <D.20555>; else goto <D.20557>;
  <D.20557>:
  D.31816 = type->type;
  klass = mono_class_from_mono_type (D.31816);
  mono_class_init_or_throw (klass);
  if (bounds != 0B) goto <D.31819>; else goto <D.31817>;
  <D.31819>:
  D.31820 = mono_array_length (bounds);
  if (D.31820 == 1) goto <D.31821>; else goto <D.31817>;
  <D.31821>:
  D.31822 = mono_array_addr_with_size (bounds, 4, 0);
  D.31823 = MEM[(gint32 *)D.31822];
  if (D.31823 != 0) goto <D.31824>; else goto <D.31817>;
  <D.31824>:
  bounded = 1;
  goto <D.31818>;
  <D.31817>:
  bounded = 0;
  <D.31818>:
  D.31825 = mono_array_length (lengths);
  aklass = mono_bounded_array_class_get (klass, D.31825, bounded);
  D.31826 = aklass->rank;
  D.31827 = (unsigned int) D.31826;
  D.31828 = D.31827 * 8;
  sizes = __builtin_alloca (D.31828);
  i = 0;
  goto <D.20559>;
  <D.20558>:
  D.31829 = i * 4;
  D.31830 = sizes + D.31829;
  D.31831 = mono_array_addr_with_size (lengths, 4, i);
  D.31832 = MEM[(guint32 *)D.31831];
  *D.31830 = D.31832;
  if (bounds != 0B) goto <D.31833>; else goto <D.31834>;
  <D.31833>:
  D.31826 = aklass->rank;
  D.31835 = (unsigned int) D.31826;
  D.31836 = D.31835 + i;
  D.31837 = D.31836 * 4;
  D.31838 = sizes + D.31837;
  D.31839 = mono_array_addr_with_size (bounds, 4, i);
  D.31840 = MEM[(gint32 *)D.31839];
  D.31841 = (unsigned int) D.31840;
  *D.31838 = D.31841;
  goto <D.31842>;
  <D.31834>:
  D.31826 = aklass->rank;
  D.31835 = (unsigned int) D.31826;
  D.31836 = D.31835 + i;
  D.31837 = D.31836 * 4;
  D.31838 = sizes + D.31837;
  *D.31838 = 0;
  <D.31842>:
  i = i + 1;
  <D.20559>:
  D.31826 = aklass->rank;
  D.31835 = (unsigned int) D.31826;
  if (D.31835 > i) goto <D.20558>; else goto <D.20560>;
  <D.20560>:
  D.31843 = MEM[(struct MonoObject *)type].vtable;
  D.31844 = D.31843->domain;
  D.31826 = aklass->rank;
  D.31827 = (unsigned int) D.31826;
  D.31845 = D.31827 * 4;
  D.31846 = sizes + D.31845;
  array = mono_array_new_full (D.31844, aklass, sizes, D.31846);
  D.31847 = array;
  return D.31847;
}


ves_icall_System_Array_ClearInternal (struct MonoArray * arr, int idx, int length)
{
  struct MonoVTable * D.31849;
  struct MonoClass * D.31850;
  double[0:] * D.31851;
  int D.31852;
  sizetype D.31853;
  void * D.31854;
  int D.31855;
  unsigned int D.31856;
  int sz;

  D.31849 = MEM[(struct MonoObject *)arr].vtable;
  D.31850 = D.31849->klass;
  sz = mono_array_element_size (D.31850);
  D.31851 = &arr->vector;
  D.31852 = sz * idx;
  D.31853 = (sizetype) D.31852;
  D.31854 = D.31851 + D.31853;
  D.31855 = length * sz;
  D.31856 = (unsigned int) D.31855;
  mono_gc_bzero_atomic (D.31854, D.31856);
}


mono_ArgIterator_Setup (struct MonoArgIterator * iter, char * argsp, char * start)
{
  struct MonoMethodSignature * D.31857;
  struct MonoMethodSignature * D.31858;
  short int D.31859;
  int D.31860;
  short unsigned int D.31861;
  int D.31862;
  _Bool D.31863;
  long int D.31864;
  long int D.31865;
  unsigned int D.31868;
  unsigned int D.31869;
  _Bool D.31870;
  long int D.31871;
  long int D.31872;
  void * D.31878;
  int D.31879;

  D.31857 = MEM[(struct MonoMethodSignature * *)argsp];
  iter->sig = D.31857;
  D.31858 = iter->sig;
  D.31859 = D.31858->sentinelpos;
  D.31860 = (int) D.31859;
  D.31858 = iter->sig;
  D.31861 = D.31858->param_count;
  D.31862 = (int) D.31861;
  D.31863 = D.31860 > D.31862;
  D.31864 = (long int) D.31863;
  D.31865 = __builtin_expect (D.31864, 0);
  if (D.31865 != 0) goto <D.31866>; else goto <D.31867>;
  <D.31866>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "icall.c", 7168, "iter->sig->sentinelpos <= iter->sig->param_count");
  <D.31867>:
  D.31858 = iter->sig;
  D.31868 = BIT_FIELD_REF <*D.31858, 32, 64>;
  D.31869 = D.31868 & 4128768;
  D.31870 = D.31869 != 327680;
  D.31871 = (long int) D.31870;
  D.31872 = __builtin_expect (D.31871, 0);
  if (D.31872 != 0) goto <D.31873>; else goto <D.31874>;
  <D.31873>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "icall.c", 7169, "iter->sig->call_convention == MONO_CALL_VARARG");
  <D.31874>:
  iter->next_arg = 0;
  if (start != 0B) goto <D.31875>; else goto <D.31876>;
  <D.31875>:
  iter->args = start;
  goto <D.31877>;
  <D.31876>:
  D.31878 = argsp + 4;
  iter->args = D.31878;
  <D.31877>:
  D.31858 = iter->sig;
  D.31861 = D.31858->param_count;
  D.31862 = (int) D.31861;
  D.31858 = iter->sig;
  D.31859 = D.31858->sentinelpos;
  D.31860 = (int) D.31859;
  D.31879 = D.31862 - D.31860;
  iter->num_args = D.31879;
}


mono_ArgIterator_IntGetNextArgType (struct MonoArgIterator * iter)
{
  struct MonoMethodSignature * D.31880;
  short int D.31881;
  int D.31882;
  int D.31883;
  short unsigned int D.31884;
  int D.31885;
  _Bool D.31886;
  long int D.31887;
  long int D.31888;
  struct MonoType * D.31891;
  gint i;

  D.31880 = iter->sig;
  D.31881 = D.31880->sentinelpos;
  D.31882 = (int) D.31881;
  D.31883 = iter->next_arg;
  i = D.31882 + D.31883;
  D.31880 = iter->sig;
  D.31884 = D.31880->param_count;
  D.31885 = (int) D.31884;
  D.31886 = D.31885 <= i;
  D.31887 = (long int) D.31886;
  D.31888 = __builtin_expect (D.31887, 0);
  if (D.31888 != 0) goto <D.31889>; else goto <D.31890>;
  <D.31889>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "icall.c", 7267, "i < iter->sig->param_count");
  <D.31890>:
  D.31880 = iter->sig;
  D.31891 = D.31880->params[i];
  return D.31891;
}


mono_ArgIterator_IntGetNextArgT (struct MonoArgIterator * iter, struct MonoType * type)
{
  struct MonoMethodSignature * D.31894;
  short int D.31895;
  int D.31896;
  int D.31897;
  int D.31898;
  short unsigned int D.31899;
  unsigned int D.31900;
  _Bool D.31901;
  long int D.31902;
  long int D.31903;
  struct MonoType * D.31906;
  int D.31907;
  struct MonoType * D.31910;
  struct MonoClass * D.31911;
  int D.31912;
  void * D.31913;
  unsigned int D.31914;
  int align.316;
  unsigned int align.317;
  unsigned int D.31917;
  unsigned int D.31918;
  int D.31919;
  unsigned int D.31920;
  unsigned int D.31921;
  void * D.31922;
  void * D.31923;
  int D.31924;
  guint32 i;
  guint32 arg_size;
  gint32 align;
  struct MonoTypedRef res;

  try
    {
      D.31894 = iter->sig;
      D.31895 = D.31894->sentinelpos;
      D.31896 = (int) D.31895;
      D.31897 = iter->next_arg;
      D.31898 = D.31896 + D.31897;
      i = (guint32) D.31898;
      D.31894 = iter->sig;
      D.31899 = D.31894->param_count;
      D.31900 = (unsigned int) D.31899;
      D.31901 = D.31900 <= i;
      D.31902 = (long int) D.31901;
      D.31903 = __builtin_expect (D.31902, 0);
      if (D.31903 != 0) goto <D.31904>; else goto <D.31905>;
      <D.31904>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "icall.c", 7233, "i < iter->sig->param_count");
      <D.31905>:
      goto <D.23078>;
      <D.23079>:
      D.31894 = iter->sig;
      D.31906 = D.31894->params[i];
      D.31907 = mono_metadata_type_equal (type, D.31906);
      if (D.31907 == 0) goto <D.31908>; else goto <D.31909>;
      <D.31908>:
      // predicted unlikely by continue predictor.
      goto <D.23078>;
      <D.31909>:
      D.31894 = iter->sig;
      D.31906 = D.31894->params[i];
      res.type = D.31906;
      D.31910 = res.type;
      D.31911 = mono_class_from_mono_type (D.31910);
      res.klass = D.31911;
      D.31910 = res.type;
      D.31912 = mono_type_stack_size (D.31910, &align);
      arg_size = (guint32) D.31912;
      D.31913 = iter->args;
      D.31914 = (unsigned int) D.31913;
      align.316 = align;
      align.317 = (unsigned int) align.316;
      D.31917 = D.31914 + align.317;
      D.31918 = D.31917 + 4294967295;
      align.316 = align;
      D.31919 = -align.316;
      D.31920 = (unsigned int) D.31919;
      D.31921 = D.31918 & D.31920;
      D.31922 = (void *) D.31921;
      iter->args = D.31922;
      D.31913 = iter->args;
      res.value = D.31913;
      D.31913 = iter->args;
      D.31923 = D.31913 + arg_size;
      iter->args = D.31923;
      D.31897 = iter->next_arg;
      D.31924 = D.31897 + 1;
      iter->next_arg = D.31924;
      <retval> = res;
      return <retval>;
      <D.23078>:
      D.31894 = iter->sig;
      D.31899 = D.31894->param_count;
      D.31900 = (unsigned int) D.31899;
      if (D.31900 > i) goto <D.23079>; else goto <D.23080>;
      <D.23080>:
      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.31928;
  short int D.31929;
  int D.31930;
  int D.31931;
  int D.31932;
  short unsigned int D.31933;
  unsigned int D.31934;
  _Bool D.31935;
  long int D.31936;
  long int D.31937;
  struct MonoType * D.31940;
  struct MonoType * D.31941;
  struct MonoClass * D.31942;
  int D.31943;
  void * D.31944;
  unsigned int D.31945;
  int align.318;
  unsigned int align.319;
  unsigned int D.31948;
  unsigned int D.31949;
  int D.31950;
  unsigned int D.31951;
  unsigned int D.31952;
  void * D.31953;
  void * D.31954;
  int D.31955;
  guint32 i;
  guint32 arg_size;
  gint32 align;
  struct MonoTypedRef res;

  try
    {
      D.31928 = iter->sig;
      D.31929 = D.31928->sentinelpos;
      D.31930 = (int) D.31929;
      D.31931 = iter->next_arg;
      D.31932 = D.31930 + D.31931;
      i = (guint32) D.31932;
      D.31928 = iter->sig;
      D.31933 = D.31928->param_count;
      D.31934 = (unsigned int) D.31933;
      D.31935 = D.31934 <= i;
      D.31936 = (long int) D.31935;
      D.31937 = __builtin_expect (D.31936, 0);
      if (D.31937 != 0) goto <D.31938>; else goto <D.31939>;
      <D.31938>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "icall.c", 7193, "i < iter->sig->param_count");
      <D.31939>:
      D.31928 = iter->sig;
      D.31940 = D.31928->params[i];
      res.type = D.31940;
      D.31941 = res.type;
      D.31942 = mono_class_from_mono_type (D.31941);
      res.klass = D.31942;
      D.31941 = res.type;
      D.31943 = mono_type_stack_size (D.31941, &align);
      arg_size = (guint32) D.31943;
      D.31944 = iter->args;
      D.31945 = (unsigned int) D.31944;
      align.318 = align;
      align.319 = (unsigned int) align.318;
      D.31948 = D.31945 + align.319;
      D.31949 = D.31948 + 4294967295;
      align.318 = align;
      D.31950 = -align.318;
      D.31951 = (unsigned int) D.31950;
      D.31952 = D.31949 & D.31951;
      D.31953 = (void *) D.31952;
      iter->args = D.31953;
      D.31944 = iter->args;
      res.value = D.31944;
      D.31944 = iter->args;
      D.31954 = D.31944 + arg_size;
      iter->args = D.31954;
      D.31931 = iter->next_arg;
      D.31955 = D.31931 + 1;
      iter->next_arg = D.31955;
      <retval> = res;
      return <retval>;
    }
  finally
    {
      align = {CLOBBER};
      res = {CLOBBER};
    }
}


ves_icall_System_Activator_CreateInstanceInternal (struct MonoReflectionType * type)
{
  struct MonoVTable * D.31958;
  struct MonoType * D.31959;
  int D.31960;
  struct MonoObject * D.31963;
  struct MonoClass * klass;
  struct MonoDomain * domain;

  D.31958 = MEM[(struct MonoObject *)type].vtable;
  domain = D.31958->domain;
  D.31959 = type->type;
  klass = mono_class_from_mono_type (D.31959);
  mono_class_init_or_throw (klass);
  D.31960 = mono_class_is_nullable (klass);
  if (D.31960 != 0) goto <D.31961>; else goto <D.31962>;
  <D.31961>:
  D.31963 = 0B;
  return D.31963;
  <D.31962>:
  D.31963 = mono_object_new (domain, klass);
  return D.31963;
}


ves_icall_Mono_Runtime_GetDisplayName ()
{
  struct MonoRuntimeCallbacks * D.31965;
  char * (*<T26e7>) (void) D.31966;
  struct MonoDomain * D.31967;
  struct MonoString * D.31968;
  char * info;
  struct MonoString * display_name;

  D.31965 = mono_get_runtime_callbacks ();
  D.31966 = D.31965->get_runtime_build_info;
  info = D.31966 ();
  D.31967 = mono_domain_get ();
  display_name = mono_string_new (D.31967, info);
  monoeg_g_free (info);
  D.31968 = display_name;
  return D.31968;
}


compare_method_imap (const void * key, const void * elem)
{
  short unsigned int D.31970;
  sizetype D.31971;
  int D.31972;
  int D.24937;
  const char * method_name;

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

    D.24937 = __builtin_strcmp (key, method_name);
  }
  D.31972 = D.24937;
  return D.31972;
}


mono_lookup_icall_symbol (struct MonoMethod * m)
{
  struct _IO_FILE * stderr.320;
  const char * D.31975;

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


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

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


mono_create_icall_signature (const char * sigstr)
{
  struct GHashTable * D.31979;
  struct MonoMethodSignature * D.31982;
  gchar * D.31983;
  int D.31984;
  unsigned int D.31985;
  gchar * D.31986;
  struct MonoType * D.31987;
  int D.31988;
  unsigned int i.321;
  unsigned int D.31990;
  gchar * * D.31991;
  gchar * D.31992;
  struct MonoType * D.31993;
  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.31979 = corlib->helper_signatures;
  res = monoeg_g_hash_table_lookup (D.31979, sigstr);
  mono_image_unlock (corlib);
  if (res != 0B) goto <D.31980>; else goto <D.31981>;
  <D.31980>:
  D.31982 = res;
  return D.31982;
  <D.31981>:
  parts = monoeg_g_strsplit (sigstr, " ", 256);
  tmp = parts;
  len = 0;
  goto <D.25161>;
  <D.25160>:
  len = len + 1;
  tmp = tmp + 4;
  <D.25161>:
  D.31983 = *tmp;
  if (D.31983 != 0B) goto <D.25160>; else goto <D.25162>;
  <D.25162>:
  D.31984 = len + -1;
  D.31985 = (unsigned int) D.31984;
  res = mono_metadata_signature_alloc (corlib, D.31985);
  res->pinvoke = 1;
  D.31986 = *parts;
  D.31987 = type_from_typename (D.31986);
  res->ret = D.31987;
  i = 1;
  goto <D.25164>;
  <D.25163>:
  D.31988 = i + -1;
  i.321 = (unsigned int) i;
  D.31990 = i.321 * 4;
  D.31991 = parts + D.31990;
  D.31992 = *D.31991;
  D.31993 = type_from_typename (D.31992);
  res->params[D.31988] = D.31993;
  i = i + 1;
  <D.25164>:
  if (i < len) goto <D.25163>; else goto <D.25165>;
  <D.25165>:
  monoeg_g_strfreev (parts);
  mono_image_lock (corlib);
  D.31979 = corlib->helper_signatures;
  res2 = monoeg_g_hash_table_lookup (D.31979, sigstr);
  if (res2 != 0B) goto <D.31994>; else goto <D.31995>;
  <D.31994>:
  res = res2;
  goto <D.31996>;
  <D.31995>:
  D.31979 = corlib->helper_signatures;
  monoeg_g_hash_table_insert_replace (D.31979, sigstr, res, 0);
  <D.31996>:
  mono_image_unlock (corlib);
  D.31982 = res;
  return D.31982;
}


type_from_typename (char * typename)
{
  int D.24995;
  int iftmp.322;
  int D.24994;
  const char[4] * D.32001;
  unsigned char D.32002;
  int D.32003;
  unsigned char D.32004;
  int D.32005;
  const unsigned char * D.32010;
  unsigned char D.32011;
  int D.32012;
  const unsigned char * D.32013;
  unsigned char D.32014;
  int D.32015;
  const unsigned char * D.32020;
  unsigned char D.32021;
  int D.32022;
  const unsigned char * D.32023;
  unsigned char D.32024;
  int D.32025;
  const unsigned char * D.32030;
  unsigned char D.32031;
  int D.32032;
  const unsigned char * D.32033;
  unsigned char D.32034;
  int D.32035;
  int D.25004;
  int iftmp.323;
  int D.25003;
  const char[4] * D.32043;
  unsigned char D.32044;
  int D.32045;
  unsigned char D.32046;
  int D.32047;
  const unsigned char * D.32052;
  unsigned char D.32053;
  int D.32054;
  const unsigned char * D.32055;
  unsigned char D.32056;
  int D.32057;
  const unsigned char * D.32062;
  unsigned char D.32063;
  int D.32064;
  const unsigned char * D.32065;
  unsigned char D.32066;
  int D.32067;
  const unsigned char * D.32072;
  unsigned char D.32073;
  int D.32074;
  const unsigned char * D.32075;
  unsigned char D.32076;
  int D.32077;
  int D.25013;
  int iftmp.324;
  int D.25012;
  const char[5] * D.32085;
  unsigned char D.32086;
  int D.32087;
  unsigned char D.32088;
  int D.32089;
  const unsigned char * D.32094;
  unsigned char D.32095;
  int D.32096;
  const unsigned char * D.32097;
  unsigned char D.32098;
  int D.32099;
  const unsigned char * D.32104;
  unsigned char D.32105;
  int D.32106;
  const unsigned char * D.32107;
  unsigned char D.32108;
  int D.32109;
  const unsigned char * D.32114;
  unsigned char D.32115;
  int D.32116;
  const unsigned char * D.32117;
  unsigned char D.32118;
  int D.32119;
  int D.25022;
  int iftmp.325;
  int D.25021;
  const char[6] * D.32127;
  unsigned char D.32128;
  int D.32129;
  unsigned char D.32130;
  int D.32131;
  const unsigned char * D.32136;
  unsigned char D.32137;
  int D.32138;
  const unsigned char * D.32139;
  unsigned char D.32140;
  int D.32141;
  const unsigned char * D.32146;
  unsigned char D.32147;
  int D.32148;
  const unsigned char * D.32149;
  unsigned char D.32150;
  int D.32151;
  const unsigned char * D.32156;
  unsigned char D.32157;
  int D.32158;
  const unsigned char * D.32159;
  unsigned char D.32160;
  int D.32161;
  int D.25031;
  int iftmp.326;
  int D.25030;
  const char[7] * D.32169;
  unsigned char D.32170;
  int D.32171;
  unsigned char D.32172;
  int D.32173;
  const unsigned char * D.32178;
  unsigned char D.32179;
  int D.32180;
  const unsigned char * D.32181;
  unsigned char D.32182;
  int D.32183;
  const unsigned char * D.32188;
  unsigned char D.32189;
  int D.32190;
  const unsigned char * D.32191;
  unsigned char D.32192;
  int D.32193;
  const unsigned char * D.32198;
  unsigned char D.32199;
  int D.32200;
  const unsigned char * D.32201;
  unsigned char D.32202;
  int D.32203;
  int D.25040;
  int iftmp.327;
  int D.25039;
  const char[5] * D.32211;
  unsigned char D.32212;
  int D.32213;
  unsigned char D.32214;
  int D.32215;
  const unsigned char * D.32220;
  unsigned char D.32221;
  int D.32222;
  const unsigned char * D.32223;
  unsigned char D.32224;
  int D.32225;
  const unsigned char * D.32230;
  unsigned char D.32231;
  int D.32232;
  const unsigned char * D.32233;
  unsigned char D.32234;
  int D.32235;
  const unsigned char * D.32240;
  unsigned char D.32241;
  int D.32242;
  const unsigned char * D.32243;
  unsigned char D.32244;
  int D.32245;
  int D.25049;
  int iftmp.328;
  int D.25048;
  const char[6] * D.32253;
  unsigned char D.32254;
  int D.32255;
  unsigned char D.32256;
  int D.32257;
  const unsigned char * D.32262;
  unsigned char D.32263;
  int D.32264;
  const unsigned char * D.32265;
  unsigned char D.32266;
  int D.32267;
  const unsigned char * D.32272;
  unsigned char D.32273;
  int D.32274;
  const unsigned char * D.32275;
  unsigned char D.32276;
  int D.32277;
  const unsigned char * D.32282;
  unsigned char D.32283;
  int D.32284;
  const unsigned char * D.32285;
  unsigned char D.32286;
  int D.32287;
  int D.25058;
  int iftmp.329;
  int D.25057;
  const char[6] * D.32295;
  unsigned char D.32296;
  int D.32297;
  unsigned char D.32298;
  int D.32299;
  const unsigned char * D.32304;
  unsigned char D.32305;
  int D.32306;
  const unsigned char * D.32307;
  unsigned char D.32308;
  int D.32309;
  const unsigned char * D.32314;
  unsigned char D.32315;
  int D.32316;
  const unsigned char * D.32317;
  unsigned char D.32318;
  int D.32319;
  const unsigned char * D.32324;
  unsigned char D.32325;
  int D.32326;
  const unsigned char * D.32327;
  unsigned char D.32328;
  int D.32329;
  int D.25067;
  int iftmp.330;
  int D.25066;
  const char[7] * D.32337;
  unsigned char D.32338;
  int D.32339;
  unsigned char D.32340;
  int D.32341;
  const unsigned char * D.32346;
  unsigned char D.32347;
  int D.32348;
  const unsigned char * D.32349;
  unsigned char D.32350;
  int D.32351;
  const unsigned char * D.32356;
  unsigned char D.32357;
  int D.32358;
  const unsigned char * D.32359;
  unsigned char D.32360;
  int D.32361;
  const unsigned char * D.32366;
  unsigned char D.32367;
  int D.32368;
  const unsigned char * D.32369;
  unsigned char D.32370;
  int D.32371;
  int D.25076;
  int iftmp.331;
  int D.25075;
  const char[5] * D.32379;
  unsigned char D.32380;
  int D.32381;
  unsigned char D.32382;
  int D.32383;
  const unsigned char * D.32388;
  unsigned char D.32389;
  int D.32390;
  const unsigned char * D.32391;
  unsigned char D.32392;
  int D.32393;
  const unsigned char * D.32398;
  unsigned char D.32399;
  int D.32400;
  const unsigned char * D.32401;
  unsigned char D.32402;
  int D.32403;
  const unsigned char * D.32408;
  unsigned char D.32409;
  int D.32410;
  const unsigned char * D.32411;
  unsigned char D.32412;
  int D.32413;
  int D.25085;
  int iftmp.332;
  int D.25084;
  const char[6] * D.32421;
  unsigned char D.32422;
  int D.32423;
  unsigned char D.32424;
  int D.32425;
  const unsigned char * D.32430;
  unsigned char D.32431;
  int D.32432;
  const unsigned char * D.32433;
  unsigned char D.32434;
  int D.32435;
  const unsigned char * D.32440;
  unsigned char D.32441;
  int D.32442;
  const unsigned char * D.32443;
  unsigned char D.32444;
  int D.32445;
  const unsigned char * D.32450;
  unsigned char D.32451;
  int D.32452;
  const unsigned char * D.32453;
  unsigned char D.32454;
  int D.32455;
  int D.25094;
  int iftmp.333;
  int D.25093;
  const char[6] * D.32463;
  unsigned char D.32464;
  int D.32465;
  unsigned char D.32466;
  int D.32467;
  const unsigned char * D.32472;
  unsigned char D.32473;
  int D.32474;
  const unsigned char * D.32475;
  unsigned char D.32476;
  int D.32477;
  const unsigned char * D.32482;
  unsigned char D.32483;
  int D.32484;
  const unsigned char * D.32485;
  unsigned char D.32486;
  int D.32487;
  const unsigned char * D.32492;
  unsigned char D.32493;
  int D.32494;
  const unsigned char * D.32495;
  unsigned char D.32496;
  int D.32497;
  int D.25103;
  int iftmp.334;
  int D.25102;
  const char[7] * D.32505;
  unsigned char D.32506;
  int D.32507;
  unsigned char D.32508;
  int D.32509;
  const unsigned char * D.32514;
  unsigned char D.32515;
  int D.32516;
  const unsigned char * D.32517;
  unsigned char D.32518;
  int D.32519;
  const unsigned char * D.32524;
  unsigned char D.32525;
  int D.32526;
  const unsigned char * D.32527;
  unsigned char D.32528;
  int D.32529;
  const unsigned char * D.32534;
  unsigned char D.32535;
  int D.32536;
  const unsigned char * D.32537;
  unsigned char D.32538;
  int D.32539;
  int D.25112;
  int iftmp.335;
  int D.25111;
  const char[7] * D.32547;
  unsigned char D.32548;
  int D.32549;
  unsigned char D.32550;
  int D.32551;
  const unsigned char * D.32556;
  unsigned char D.32557;
  int D.32558;
  const unsigned char * D.32559;
  unsigned char D.32560;
  int D.32561;
  const unsigned char * D.32566;
  unsigned char D.32567;
  int D.32568;
  const unsigned char * D.32569;
  unsigned char D.32570;
  int D.32571;
  const unsigned char * D.32576;
  unsigned char D.32577;
  int D.32578;
  const unsigned char * D.32579;
  unsigned char D.32580;
  int D.32581;
  int D.25121;
  int iftmp.336;
  int D.25120;
  const char[4] * D.32589;
  unsigned char D.32590;
  int D.32591;
  unsigned char D.32592;
  int D.32593;
  const unsigned char * D.32598;
  unsigned char D.32599;
  int D.32600;
  const unsigned char * D.32601;
  unsigned char D.32602;
  int D.32603;
  const unsigned char * D.32608;
  unsigned char D.32609;
  int D.32610;
  const unsigned char * D.32611;
  unsigned char D.32612;
  int D.32613;
  const unsigned char * D.32618;
  unsigned char D.32619;
  int D.32620;
  const unsigned char * D.32621;
  unsigned char D.32622;
  int D.32623;
  int D.25130;
  int iftmp.337;
  int D.25129;
  const char[7] * D.32631;
  unsigned char D.32632;
  int D.32633;
  unsigned char D.32634;
  int D.32635;
  const unsigned char * D.32640;
  unsigned char D.32641;
  int D.32642;
  const unsigned char * D.32643;
  unsigned char D.32644;
  int D.32645;
  const unsigned char * D.32650;
  unsigned char D.32651;
  int D.32652;
  const unsigned char * D.32653;
  unsigned char D.32654;
  int D.32655;
  const unsigned char * D.32660;
  unsigned char D.32661;
  int D.32662;
  const unsigned char * D.32663;
  unsigned char D.32664;
  int D.32665;
  int D.25139;
  int iftmp.338;
  int D.25138;
  const char[5] * D.32673;
  unsigned char D.32674;
  int D.32675;
  unsigned char D.32676;
  int D.32677;
  const unsigned char * D.32682;
  unsigned char D.32683;
  int D.32684;
  const unsigned char * D.32685;
  unsigned char D.32686;
  int D.32687;
  const unsigned char * D.32692;
  unsigned char D.32693;
  int D.32694;
  const unsigned char * D.32695;
  unsigned char D.32696;
  int D.32697;
  const unsigned char * D.32702;
  unsigned char D.32703;
  int D.32704;
  const unsigned char * D.32705;
  unsigned char D.32706;
  int D.32707;
  int D.25148;
  int iftmp.339;
  int D.25147;
  const char[8] * D.32715;
  unsigned char D.32716;
  int D.32717;
  unsigned char D.32718;
  int D.32719;
  const unsigned char * D.32724;
  unsigned char D.32725;
  int D.32726;
  const unsigned char * D.32727;
  unsigned char D.32728;
  int D.32729;
  const unsigned char * D.32734;
  unsigned char D.32735;
  int D.32736;
  const unsigned char * D.32737;
  unsigned char D.32738;
  int D.32739;
  const unsigned char * D.32744;
  unsigned char D.32745;
  int D.32746;
  const unsigned char * D.32747;
  unsigned char D.32748;
  int D.32749;
  struct MonoType * D.32754;
  struct MonoClass * klass;

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

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

      __s2 = typename;
      D.32001 = "int";
      D.32002 = MEM[(const unsigned char *)D.32001];
      D.32003 = (int) D.32002;
      D.32004 = *__s2;
      D.32005 = (int) D.32004;
      __result = D.32003 - D.32005;
      {
        if (__s2_len != 0) goto <D.32006>; else goto <D.32007>;
        <D.32006>:
        if (__result == 0) goto <D.32008>; else goto <D.32009>;
        <D.32008>:
        D.32010 = &MEM[(void *)"int" + 1B];
        D.32011 = *D.32010;
        D.32012 = (int) D.32011;
        D.32013 = __s2 + 1;
        D.32014 = *D.32013;
        D.32015 = (int) D.32014;
        __result = D.32012 - D.32015;
        if (__s2_len > 1) goto <D.32016>; else goto <D.32017>;
        <D.32016>:
        if (__result == 0) goto <D.32018>; else goto <D.32019>;
        <D.32018>:
        D.32020 = &MEM[(void *)"int" + 2B];
        D.32021 = *D.32020;
        D.32022 = (int) D.32021;
        D.32023 = __s2 + 2;
        D.32024 = *D.32023;
        D.32025 = (int) D.32024;
        __result = D.32022 - D.32025;
        if (__s2_len > 2) goto <D.32026>; else goto <D.32027>;
        <D.32026>:
        if (__result == 0) goto <D.32028>; else goto <D.32029>;
        <D.32028>:
        D.32030 = &MEM[(void *)"int" + 3B];
        D.32031 = *D.32030;
        D.32032 = (int) D.32031;
        D.32033 = __s2 + 3;
        D.32034 = *D.32033;
        D.32035 = (int) D.32034;
        __result = D.32032 - D.32035;
        <D.32029>:
        <D.32027>:
        <D.32019>:
        <D.32017>:
        <D.32009>:
        <D.32007>:
      }
      D.24994 = __result;
    }
    iftmp.322 = -D.24994;
    goto <D.32036>;
    <D.32000>:
    iftmp.322 = __builtin_strcmp (typename, "int");
    <D.32036>:
    D.24995 = iftmp.322;
  }
  if (D.24995 == 0) goto <D.32037>; else goto <D.32038>;
  <D.32037>:
  klass = mono_defaults.int_class;
  goto <D.32039>;
  <D.32038>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = typename;
      D.32043 = "ptr";
      D.32044 = MEM[(const unsigned char *)D.32043];
      D.32045 = (int) D.32044;
      D.32046 = *__s2;
      D.32047 = (int) D.32046;
      __result = D.32045 - D.32047;
      {
        if (__s2_len != 0) goto <D.32048>; else goto <D.32049>;
        <D.32048>:
        if (__result == 0) goto <D.32050>; else goto <D.32051>;
        <D.32050>:
        D.32052 = &MEM[(void *)"ptr" + 1B];
        D.32053 = *D.32052;
        D.32054 = (int) D.32053;
        D.32055 = __s2 + 1;
        D.32056 = *D.32055;
        D.32057 = (int) D.32056;
        __result = D.32054 - D.32057;
        if (__s2_len > 1) goto <D.32058>; else goto <D.32059>;
        <D.32058>:
        if (__result == 0) goto <D.32060>; else goto <D.32061>;
        <D.32060>:
        D.32062 = &MEM[(void *)"ptr" + 2B];
        D.32063 = *D.32062;
        D.32064 = (int) D.32063;
        D.32065 = __s2 + 2;
        D.32066 = *D.32065;
        D.32067 = (int) D.32066;
        __result = D.32064 - D.32067;
        if (__s2_len > 2) goto <D.32068>; else goto <D.32069>;
        <D.32068>:
        if (__result == 0) goto <D.32070>; else goto <D.32071>;
        <D.32070>:
        D.32072 = &MEM[(void *)"ptr" + 3B];
        D.32073 = *D.32072;
        D.32074 = (int) D.32073;
        D.32075 = __s2 + 3;
        D.32076 = *D.32075;
        D.32077 = (int) D.32076;
        __result = D.32074 - D.32077;
        <D.32071>:
        <D.32069>:
        <D.32061>:
        <D.32059>:
        <D.32051>:
        <D.32049>:
      }
      D.25003 = __result;
    }
    iftmp.323 = -D.25003;
    goto <D.32078>;
    <D.32042>:
    iftmp.323 = __builtin_strcmp (typename, "ptr");
    <D.32078>:
    D.25004 = iftmp.323;
  }
  if (D.25004 == 0) goto <D.32079>; else goto <D.32080>;
  <D.32079>:
  klass = mono_defaults.int_class;
  goto <D.32081>;
  <D.32080>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

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

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

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

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

      __s2 = typename;
      D.32169 = "uint32";
      D.32170 = MEM[(const unsigned char *)D.32169];
      D.32171 = (int) D.32170;
      D.32172 = *__s2;
      D.32173 = (int) D.32172;
      __result = D.32171 - D.32173;
      {
        if (__s2_len != 0) goto <D.32174>; else goto <D.32175>;
        <D.32174>:
        if (__result == 0) goto <D.32176>; else goto <D.32177>;
        <D.32176>:
        D.32178 = &MEM[(void *)"uint32" + 1B];
        D.32179 = *D.32178;
        D.32180 = (int) D.32179;
        D.32181 = __s2 + 1;
        D.32182 = *D.32181;
        D.32183 = (int) D.32182;
        __result = D.32180 - D.32183;
        if (__s2_len > 1) goto <D.32184>; else goto <D.32185>;
        <D.32184>:
        if (__result == 0) goto <D.32186>; else goto <D.32187>;
        <D.32186>:
        D.32188 = &MEM[(void *)"uint32" + 2B];
        D.32189 = *D.32188;
        D.32190 = (int) D.32189;
        D.32191 = __s2 + 2;
        D.32192 = *D.32191;
        D.32193 = (int) D.32192;
        __result = D.32190 - D.32193;
        if (__s2_len > 2) goto <D.32194>; else goto <D.32195>;
        <D.32194>:
        if (__result == 0) goto <D.32196>; else goto <D.32197>;
        <D.32196>:
        D.32198 = &MEM[(void *)"uint32" + 3B];
        D.32199 = *D.32198;
        D.32200 = (int) D.32199;
        D.32201 = __s2 + 3;
        D.32202 = *D.32201;
        D.32203 = (int) D.32202;
        __result = D.32200 - D.32203;
        <D.32197>:
        <D.32195>:
        <D.32187>:
        <D.32185>:
        <D.32177>:
        <D.32175>:
      }
      D.25030 = __result;
    }
    iftmp.326 = -D.25030;
    goto <D.32204>;
    <D.32168>:
    iftmp.326 = __builtin_strcmp (typename, "uint32");
    <D.32204>:
    D.25031 = iftmp.326;
  }
  if (D.25031 == 0) goto <D.32205>; else goto <D.32206>;
  <D.32205>:
  klass = mono_defaults.uint32_class;
  goto <D.32207>;
  <D.32206>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = typename;
      D.32211 = "int8";
      D.32212 = MEM[(const unsigned char *)D.32211];
      D.32213 = (int) D.32212;
      D.32214 = *__s2;
      D.32215 = (int) D.32214;
      __result = D.32213 - D.32215;
      {
        if (__s2_len != 0) goto <D.32216>; else goto <D.32217>;
        <D.32216>:
        if (__result == 0) goto <D.32218>; else goto <D.32219>;
        <D.32218>:
        D.32220 = &MEM[(void *)"int8" + 1B];
        D.32221 = *D.32220;
        D.32222 = (int) D.32221;
        D.32223 = __s2 + 1;
        D.32224 = *D.32223;
        D.32225 = (int) D.32224;
        __result = D.32222 - D.32225;
        if (__s2_len > 1) goto <D.32226>; else goto <D.32227>;
        <D.32226>:
        if (__result == 0) goto <D.32228>; else goto <D.32229>;
        <D.32228>:
        D.32230 = &MEM[(void *)"int8" + 2B];
        D.32231 = *D.32230;
        D.32232 = (int) D.32231;
        D.32233 = __s2 + 2;
        D.32234 = *D.32233;
        D.32235 = (int) D.32234;
        __result = D.32232 - D.32235;
        if (__s2_len > 2) goto <D.32236>; else goto <D.32237>;
        <D.32236>:
        if (__result == 0) goto <D.32238>; else goto <D.32239>;
        <D.32238>:
        D.32240 = &MEM[(void *)"int8" + 3B];
        D.32241 = *D.32240;
        D.32242 = (int) D.32241;
        D.32243 = __s2 + 3;
        D.32244 = *D.32243;
        D.32245 = (int) D.32244;
        __result = D.32242 - D.32245;
        <D.32239>:
        <D.32237>:
        <D.32229>:
        <D.32227>:
        <D.32219>:
        <D.32217>:
      }
      D.25039 = __result;
    }
    iftmp.327 = -D.25039;
    goto <D.32246>;
    <D.32210>:
    iftmp.327 = __builtin_strcmp (typename, "int8");
    <D.32246>:
    D.25040 = iftmp.327;
  }
  if (D.25040 == 0) goto <D.32247>; else goto <D.32248>;
  <D.32247>:
  klass = mono_defaults.sbyte_class;
  goto <D.32249>;
  <D.32248>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = typename;
      D.32253 = "uint8";
      D.32254 = MEM[(const unsigned char *)D.32253];
      D.32255 = (int) D.32254;
      D.32256 = *__s2;
      D.32257 = (int) D.32256;
      __result = D.32255 - D.32257;
      {
        if (__s2_len != 0) goto <D.32258>; else goto <D.32259>;
        <D.32258>:
        if (__result == 0) goto <D.32260>; else goto <D.32261>;
        <D.32260>:
        D.32262 = &MEM[(void *)"uint8" + 1B];
        D.32263 = *D.32262;
        D.32264 = (int) D.32263;
        D.32265 = __s2 + 1;
        D.32266 = *D.32265;
        D.32267 = (int) D.32266;
        __result = D.32264 - D.32267;
        if (__s2_len > 1) goto <D.32268>; else goto <D.32269>;
        <D.32268>:
        if (__result == 0) goto <D.32270>; else goto <D.32271>;
        <D.32270>:
        D.32272 = &MEM[(void *)"uint8" + 2B];
        D.32273 = *D.32272;
        D.32274 = (int) D.32273;
        D.32275 = __s2 + 2;
        D.32276 = *D.32275;
        D.32277 = (int) D.32276;
        __result = D.32274 - D.32277;
        if (__s2_len > 2) goto <D.32278>; else goto <D.32279>;
        <D.32278>:
        if (__result == 0) goto <D.32280>; else goto <D.32281>;
        <D.32280>:
        D.32282 = &MEM[(void *)"uint8" + 3B];
        D.32283 = *D.32282;
        D.32284 = (int) D.32283;
        D.32285 = __s2 + 3;
        D.32286 = *D.32285;
        D.32287 = (int) D.32286;
        __result = D.32284 - D.32287;
        <D.32281>:
        <D.32279>:
        <D.32271>:
        <D.32269>:
        <D.32261>:
        <D.32259>:
      }
      D.25048 = __result;
    }
    iftmp.328 = -D.25048;
    goto <D.32288>;
    <D.32252>:
    iftmp.328 = __builtin_strcmp (typename, "uint8");
    <D.32288>:
    D.25049 = iftmp.328;
  }
  if (D.25049 == 0) goto <D.32289>; else goto <D.32290>;
  <D.32289>:
  klass = mono_defaults.byte_class;
  goto <D.32291>;
  <D.32290>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = typename;
      D.32295 = "int16";
      D.32296 = MEM[(const unsigned char *)D.32295];
      D.32297 = (int) D.32296;
      D.32298 = *__s2;
      D.32299 = (int) D.32298;
      __result = D.32297 - D.32299;
      {
        if (__s2_len != 0) goto <D.32300>; else goto <D.32301>;
        <D.32300>:
        if (__result == 0) goto <D.32302>; else goto <D.32303>;
        <D.32302>:
        D.32304 = &MEM[(void *)"int16" + 1B];
        D.32305 = *D.32304;
        D.32306 = (int) D.32305;
        D.32307 = __s2 + 1;
        D.32308 = *D.32307;
        D.32309 = (int) D.32308;
        __result = D.32306 - D.32309;
        if (__s2_len > 1) goto <D.32310>; else goto <D.32311>;
        <D.32310>:
        if (__result == 0) goto <D.32312>; else goto <D.32313>;
        <D.32312>:
        D.32314 = &MEM[(void *)"int16" + 2B];
        D.32315 = *D.32314;
        D.32316 = (int) D.32315;
        D.32317 = __s2 + 2;
        D.32318 = *D.32317;
        D.32319 = (int) D.32318;
        __result = D.32316 - D.32319;
        if (__s2_len > 2) goto <D.32320>; else goto <D.32321>;
        <D.32320>:
        if (__result == 0) goto <D.32322>; else goto <D.32323>;
        <D.32322>:
        D.32324 = &MEM[(void *)"int16" + 3B];
        D.32325 = *D.32324;
        D.32326 = (int) D.32325;
        D.32327 = __s2 + 3;
        D.32328 = *D.32327;
        D.32329 = (int) D.32328;
        __result = D.32326 - D.32329;
        <D.32323>:
        <D.32321>:
        <D.32313>:
        <D.32311>:
        <D.32303>:
        <D.32301>:
      }
      D.25057 = __result;
    }
    iftmp.329 = -D.25057;
    goto <D.32330>;
    <D.32294>:
    iftmp.329 = __builtin_strcmp (typename, "int16");
    <D.32330>:
    D.25058 = iftmp.329;
  }
  if (D.25058 == 0) goto <D.32331>; else goto <D.32332>;
  <D.32331>:
  klass = mono_defaults.int16_class;
  goto <D.32333>;
  <D.32332>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = typename;
      D.32337 = "uint16";
      D.32338 = MEM[(const unsigned char *)D.32337];
      D.32339 = (int) D.32338;
      D.32340 = *__s2;
      D.32341 = (int) D.32340;
      __result = D.32339 - D.32341;
      {
        if (__s2_len != 0) goto <D.32342>; else goto <D.32343>;
        <D.32342>:
        if (__result == 0) goto <D.32344>; else goto <D.32345>;
        <D.32344>:
        D.32346 = &MEM[(void *)"uint16" + 1B];
        D.32347 = *D.32346;
        D.32348 = (int) D.32347;
        D.32349 = __s2 + 1;
        D.32350 = *D.32349;
        D.32351 = (int) D.32350;
        __result = D.32348 - D.32351;
        if (__s2_len > 1) goto <D.32352>; else goto <D.32353>;
        <D.32352>:
        if (__result == 0) goto <D.32354>; else goto <D.32355>;
        <D.32354>:
        D.32356 = &MEM[(void *)"uint16" + 2B];
        D.32357 = *D.32356;
        D.32358 = (int) D.32357;
        D.32359 = __s2 + 2;
        D.32360 = *D.32359;
        D.32361 = (int) D.32360;
        __result = D.32358 - D.32361;
        if (__s2_len > 2) goto <D.32362>; else goto <D.32363>;
        <D.32362>:
        if (__result == 0) goto <D.32364>; else goto <D.32365>;
        <D.32364>:
        D.32366 = &MEM[(void *)"uint16" + 3B];
        D.32367 = *D.32366;
        D.32368 = (int) D.32367;
        D.32369 = __s2 + 3;
        D.32370 = *D.32369;
        D.32371 = (int) D.32370;
        __result = D.32368 - D.32371;
        <D.32365>:
        <D.32363>:
        <D.32355>:
        <D.32353>:
        <D.32345>:
        <D.32343>:
      }
      D.25066 = __result;
    }
    iftmp.330 = -D.25066;
    goto <D.32372>;
    <D.32336>:
    iftmp.330 = __builtin_strcmp (typename, "uint16");
    <D.32372>:
    D.25067 = iftmp.330;
  }
  if (D.25067 == 0) goto <D.32373>; else goto <D.32374>;
  <D.32373>:
  klass = mono_defaults.uint16_class;
  goto <D.32375>;
  <D.32374>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = typename;
      D.32379 = "long";
      D.32380 = MEM[(const unsigned char *)D.32379];
      D.32381 = (int) D.32380;
      D.32382 = *__s2;
      D.32383 = (int) D.32382;
      __result = D.32381 - D.32383;
      {
        if (__s2_len != 0) goto <D.32384>; else goto <D.32385>;
        <D.32384>:
        if (__result == 0) goto <D.32386>; else goto <D.32387>;
        <D.32386>:
        D.32388 = &MEM[(void *)"long" + 1B];
        D.32389 = *D.32388;
        D.32390 = (int) D.32389;
        D.32391 = __s2 + 1;
        D.32392 = *D.32391;
        D.32393 = (int) D.32392;
        __result = D.32390 - D.32393;
        if (__s2_len > 1) goto <D.32394>; else goto <D.32395>;
        <D.32394>:
        if (__result == 0) goto <D.32396>; else goto <D.32397>;
        <D.32396>:
        D.32398 = &MEM[(void *)"long" + 2B];
        D.32399 = *D.32398;
        D.32400 = (int) D.32399;
        D.32401 = __s2 + 2;
        D.32402 = *D.32401;
        D.32403 = (int) D.32402;
        __result = D.32400 - D.32403;
        if (__s2_len > 2) goto <D.32404>; else goto <D.32405>;
        <D.32404>:
        if (__result == 0) goto <D.32406>; else goto <D.32407>;
        <D.32406>:
        D.32408 = &MEM[(void *)"long" + 3B];
        D.32409 = *D.32408;
        D.32410 = (int) D.32409;
        D.32411 = __s2 + 3;
        D.32412 = *D.32411;
        D.32413 = (int) D.32412;
        __result = D.32410 - D.32413;
        <D.32407>:
        <D.32405>:
        <D.32397>:
        <D.32395>:
        <D.32387>:
        <D.32385>:
      }
      D.25075 = __result;
    }
    iftmp.331 = -D.25075;
    goto <D.32414>;
    <D.32378>:
    iftmp.331 = __builtin_strcmp (typename, "long");
    <D.32414>:
    D.25076 = iftmp.331;
  }
  if (D.25076 == 0) goto <D.32415>; else goto <D.32416>;
  <D.32415>:
  klass = mono_defaults.int64_class;
  goto <D.32417>;
  <D.32416>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = typename;
      D.32421 = "ulong";
      D.32422 = MEM[(const unsigned char *)D.32421];
      D.32423 = (int) D.32422;
      D.32424 = *__s2;
      D.32425 = (int) D.32424;
      __result = D.32423 - D.32425;
      {
        if (__s2_len != 0) goto <D.32426>; else goto <D.32427>;
        <D.32426>:
        if (__result == 0) goto <D.32428>; else goto <D.32429>;
        <D.32428>:
        D.32430 = &MEM[(void *)"ulong" + 1B];
        D.32431 = *D.32430;
        D.32432 = (int) D.32431;
        D.32433 = __s2 + 1;
        D.32434 = *D.32433;
        D.32435 = (int) D.32434;
        __result = D.32432 - D.32435;
        if (__s2_len > 1) goto <D.32436>; else goto <D.32437>;
        <D.32436>:
        if (__result == 0) goto <D.32438>; else goto <D.32439>;
        <D.32438>:
        D.32440 = &MEM[(void *)"ulong" + 2B];
        D.32441 = *D.32440;
        D.32442 = (int) D.32441;
        D.32443 = __s2 + 2;
        D.32444 = *D.32443;
        D.32445 = (int) D.32444;
        __result = D.32442 - D.32445;
        if (__s2_len > 2) goto <D.32446>; else goto <D.32447>;
        <D.32446>:
        if (__result == 0) goto <D.32448>; else goto <D.32449>;
        <D.32448>:
        D.32450 = &MEM[(void *)"ulong" + 3B];
        D.32451 = *D.32450;
        D.32452 = (int) D.32451;
        D.32453 = __s2 + 3;
        D.32454 = *D.32453;
        D.32455 = (int) D.32454;
        __result = D.32452 - D.32455;
        <D.32449>:
        <D.32447>:
        <D.32439>:
        <D.32437>:
        <D.32429>:
        <D.32427>:
      }
      D.25084 = __result;
    }
    iftmp.332 = -D.25084;
    goto <D.32456>;
    <D.32420>:
    iftmp.332 = __builtin_strcmp (typename, "ulong");
    <D.32456>:
    D.25085 = iftmp.332;
  }
  if (D.25085 == 0) goto <D.32457>; else goto <D.32458>;
  <D.32457>:
  klass = mono_defaults.uint64_class;
  goto <D.32459>;
  <D.32458>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = typename;
      D.32463 = "float";
      D.32464 = MEM[(const unsigned char *)D.32463];
      D.32465 = (int) D.32464;
      D.32466 = *__s2;
      D.32467 = (int) D.32466;
      __result = D.32465 - D.32467;
      {
        if (__s2_len != 0) goto <D.32468>; else goto <D.32469>;
        <D.32468>:
        if (__result == 0) goto <D.32470>; else goto <D.32471>;
        <D.32470>:
        D.32472 = &MEM[(void *)"float" + 1B];
        D.32473 = *D.32472;
        D.32474 = (int) D.32473;
        D.32475 = __s2 + 1;
        D.32476 = *D.32475;
        D.32477 = (int) D.32476;
        __result = D.32474 - D.32477;
        if (__s2_len > 1) goto <D.32478>; else goto <D.32479>;
        <D.32478>:
        if (__result == 0) goto <D.32480>; else goto <D.32481>;
        <D.32480>:
        D.32482 = &MEM[(void *)"float" + 2B];
        D.32483 = *D.32482;
        D.32484 = (int) D.32483;
        D.32485 = __s2 + 2;
        D.32486 = *D.32485;
        D.32487 = (int) D.32486;
        __result = D.32484 - D.32487;
        if (__s2_len > 2) goto <D.32488>; else goto <D.32489>;
        <D.32488>:
        if (__result == 0) goto <D.32490>; else goto <D.32491>;
        <D.32490>:
        D.32492 = &MEM[(void *)"float" + 3B];
        D.32493 = *D.32492;
        D.32494 = (int) D.32493;
        D.32495 = __s2 + 3;
        D.32496 = *D.32495;
        D.32497 = (int) D.32496;
        __result = D.32494 - D.32497;
        <D.32491>:
        <D.32489>:
        <D.32481>:
        <D.32479>:
        <D.32471>:
        <D.32469>:
      }
      D.25093 = __result;
    }
    iftmp.333 = -D.25093;
    goto <D.32498>;
    <D.32462>:
    iftmp.333 = __builtin_strcmp (typename, "float");
    <D.32498>:
    D.25094 = iftmp.333;
  }
  if (D.25094 == 0) goto <D.32499>; else goto <D.32500>;
  <D.32499>:
  klass = mono_defaults.single_class;
  goto <D.32501>;
  <D.32500>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = typename;
      D.32505 = "double";
      D.32506 = MEM[(const unsigned char *)D.32505];
      D.32507 = (int) D.32506;
      D.32508 = *__s2;
      D.32509 = (int) D.32508;
      __result = D.32507 - D.32509;
      {
        if (__s2_len != 0) goto <D.32510>; else goto <D.32511>;
        <D.32510>:
        if (__result == 0) goto <D.32512>; else goto <D.32513>;
        <D.32512>:
        D.32514 = &MEM[(void *)"double" + 1B];
        D.32515 = *D.32514;
        D.32516 = (int) D.32515;
        D.32517 = __s2 + 1;
        D.32518 = *D.32517;
        D.32519 = (int) D.32518;
        __result = D.32516 - D.32519;
        if (__s2_len > 1) goto <D.32520>; else goto <D.32521>;
        <D.32520>:
        if (__result == 0) goto <D.32522>; else goto <D.32523>;
        <D.32522>:
        D.32524 = &MEM[(void *)"double" + 2B];
        D.32525 = *D.32524;
        D.32526 = (int) D.32525;
        D.32527 = __s2 + 2;
        D.32528 = *D.32527;
        D.32529 = (int) D.32528;
        __result = D.32526 - D.32529;
        if (__s2_len > 2) goto <D.32530>; else goto <D.32531>;
        <D.32530>:
        if (__result == 0) goto <D.32532>; else goto <D.32533>;
        <D.32532>:
        D.32534 = &MEM[(void *)"double" + 3B];
        D.32535 = *D.32534;
        D.32536 = (int) D.32535;
        D.32537 = __s2 + 3;
        D.32538 = *D.32537;
        D.32539 = (int) D.32538;
        __result = D.32536 - D.32539;
        <D.32533>:
        <D.32531>:
        <D.32523>:
        <D.32521>:
        <D.32513>:
        <D.32511>:
      }
      D.25102 = __result;
    }
    iftmp.334 = -D.25102;
    goto <D.32540>;
    <D.32504>:
    iftmp.334 = __builtin_strcmp (typename, "double");
    <D.32540>:
    D.25103 = iftmp.334;
  }
  if (D.25103 == 0) goto <D.32541>; else goto <D.32542>;
  <D.32541>:
  klass = mono_defaults.double_class;
  goto <D.32543>;
  <D.32542>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = typename;
      D.32547 = "object";
      D.32548 = MEM[(const unsigned char *)D.32547];
      D.32549 = (int) D.32548;
      D.32550 = *__s2;
      D.32551 = (int) D.32550;
      __result = D.32549 - D.32551;
      {
        if (__s2_len != 0) goto <D.32552>; else goto <D.32553>;
        <D.32552>:
        if (__result == 0) goto <D.32554>; else goto <D.32555>;
        <D.32554>:
        D.32556 = &MEM[(void *)"object" + 1B];
        D.32557 = *D.32556;
        D.32558 = (int) D.32557;
        D.32559 = __s2 + 1;
        D.32560 = *D.32559;
        D.32561 = (int) D.32560;
        __result = D.32558 - D.32561;
        if (__s2_len > 1) goto <D.32562>; else goto <D.32563>;
        <D.32562>:
        if (__result == 0) goto <D.32564>; else goto <D.32565>;
        <D.32564>:
        D.32566 = &MEM[(void *)"object" + 2B];
        D.32567 = *D.32566;
        D.32568 = (int) D.32567;
        D.32569 = __s2 + 2;
        D.32570 = *D.32569;
        D.32571 = (int) D.32570;
        __result = D.32568 - D.32571;
        if (__s2_len > 2) goto <D.32572>; else goto <D.32573>;
        <D.32572>:
        if (__result == 0) goto <D.32574>; else goto <D.32575>;
        <D.32574>:
        D.32576 = &MEM[(void *)"object" + 3B];
        D.32577 = *D.32576;
        D.32578 = (int) D.32577;
        D.32579 = __s2 + 3;
        D.32580 = *D.32579;
        D.32581 = (int) D.32580;
        __result = D.32578 - D.32581;
        <D.32575>:
        <D.32573>:
        <D.32565>:
        <D.32563>:
        <D.32555>:
        <D.32553>:
      }
      D.25111 = __result;
    }
    iftmp.335 = -D.25111;
    goto <D.32582>;
    <D.32546>:
    iftmp.335 = __builtin_strcmp (typename, "object");
    <D.32582>:
    D.25112 = iftmp.335;
  }
  if (D.25112 == 0) goto <D.32583>; else goto <D.32584>;
  <D.32583>:
  klass = mono_defaults.object_class;
  goto <D.32585>;
  <D.32584>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = typename;
      D.32589 = "obj";
      D.32590 = MEM[(const unsigned char *)D.32589];
      D.32591 = (int) D.32590;
      D.32592 = *__s2;
      D.32593 = (int) D.32592;
      __result = D.32591 - D.32593;
      {
        if (__s2_len != 0) goto <D.32594>; else goto <D.32595>;
        <D.32594>:
        if (__result == 0) goto <D.32596>; else goto <D.32597>;
        <D.32596>:
        D.32598 = &MEM[(void *)"obj" + 1B];
        D.32599 = *D.32598;
        D.32600 = (int) D.32599;
        D.32601 = __s2 + 1;
        D.32602 = *D.32601;
        D.32603 = (int) D.32602;
        __result = D.32600 - D.32603;
        if (__s2_len > 1) goto <D.32604>; else goto <D.32605>;
        <D.32604>:
        if (__result == 0) goto <D.32606>; else goto <D.32607>;
        <D.32606>:
        D.32608 = &MEM[(void *)"obj" + 2B];
        D.32609 = *D.32608;
        D.32610 = (int) D.32609;
        D.32611 = __s2 + 2;
        D.32612 = *D.32611;
        D.32613 = (int) D.32612;
        __result = D.32610 - D.32613;
        if (__s2_len > 2) goto <D.32614>; else goto <D.32615>;
        <D.32614>:
        if (__result == 0) goto <D.32616>; else goto <D.32617>;
        <D.32616>:
        D.32618 = &MEM[(void *)"obj" + 3B];
        D.32619 = *D.32618;
        D.32620 = (int) D.32619;
        D.32621 = __s2 + 3;
        D.32622 = *D.32621;
        D.32623 = (int) D.32622;
        __result = D.32620 - D.32623;
        <D.32617>:
        <D.32615>:
        <D.32607>:
        <D.32605>:
        <D.32597>:
        <D.32595>:
      }
      D.25120 = __result;
    }
    iftmp.336 = -D.25120;
    goto <D.32624>;
    <D.32588>:
    iftmp.336 = __builtin_strcmp (typename, "obj");
    <D.32624>:
    D.25121 = iftmp.336;
  }
  if (D.25121 == 0) goto <D.32625>; else goto <D.32626>;
  <D.32625>:
  klass = mono_defaults.object_class;
  goto <D.32627>;
  <D.32626>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = typename;
      D.32631 = "string";
      D.32632 = MEM[(const unsigned char *)D.32631];
      D.32633 = (int) D.32632;
      D.32634 = *__s2;
      D.32635 = (int) D.32634;
      __result = D.32633 - D.32635;
      {
        if (__s2_len != 0) goto <D.32636>; else goto <D.32637>;
        <D.32636>:
        if (__result == 0) goto <D.32638>; else goto <D.32639>;
        <D.32638>:
        D.32640 = &MEM[(void *)"string" + 1B];
        D.32641 = *D.32640;
        D.32642 = (int) D.32641;
        D.32643 = __s2 + 1;
        D.32644 = *D.32643;
        D.32645 = (int) D.32644;
        __result = D.32642 - D.32645;
        if (__s2_len > 1) goto <D.32646>; else goto <D.32647>;
        <D.32646>:
        if (__result == 0) goto <D.32648>; else goto <D.32649>;
        <D.32648>:
        D.32650 = &MEM[(void *)"string" + 2B];
        D.32651 = *D.32650;
        D.32652 = (int) D.32651;
        D.32653 = __s2 + 2;
        D.32654 = *D.32653;
        D.32655 = (int) D.32654;
        __result = D.32652 - D.32655;
        if (__s2_len > 2) goto <D.32656>; else goto <D.32657>;
        <D.32656>:
        if (__result == 0) goto <D.32658>; else goto <D.32659>;
        <D.32658>:
        D.32660 = &MEM[(void *)"string" + 3B];
        D.32661 = *D.32660;
        D.32662 = (int) D.32661;
        D.32663 = __s2 + 3;
        D.32664 = *D.32663;
        D.32665 = (int) D.32664;
        __result = D.32662 - D.32665;
        <D.32659>:
        <D.32657>:
        <D.32649>:
        <D.32647>:
        <D.32639>:
        <D.32637>:
      }
      D.25129 = __result;
    }
    iftmp.337 = -D.25129;
    goto <D.32666>;
    <D.32630>:
    iftmp.337 = __builtin_strcmp (typename, "string");
    <D.32666>:
    D.25130 = iftmp.337;
  }
  if (D.25130 == 0) goto <D.32667>; else goto <D.32668>;
  <D.32667>:
  klass = mono_defaults.string_class;
  goto <D.32669>;
  <D.32668>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = typename;
      D.32673 = "bool";
      D.32674 = MEM[(const unsigned char *)D.32673];
      D.32675 = (int) D.32674;
      D.32676 = *__s2;
      D.32677 = (int) D.32676;
      __result = D.32675 - D.32677;
      {
        if (__s2_len != 0) goto <D.32678>; else goto <D.32679>;
        <D.32678>:
        if (__result == 0) goto <D.32680>; else goto <D.32681>;
        <D.32680>:
        D.32682 = &MEM[(void *)"bool" + 1B];
        D.32683 = *D.32682;
        D.32684 = (int) D.32683;
        D.32685 = __s2 + 1;
        D.32686 = *D.32685;
        D.32687 = (int) D.32686;
        __result = D.32684 - D.32687;
        if (__s2_len > 1) goto <D.32688>; else goto <D.32689>;
        <D.32688>:
        if (__result == 0) goto <D.32690>; else goto <D.32691>;
        <D.32690>:
        D.32692 = &MEM[(void *)"bool" + 2B];
        D.32693 = *D.32692;
        D.32694 = (int) D.32693;
        D.32695 = __s2 + 2;
        D.32696 = *D.32695;
        D.32697 = (int) D.32696;
        __result = D.32694 - D.32697;
        if (__s2_len > 2) goto <D.32698>; else goto <D.32699>;
        <D.32698>:
        if (__result == 0) goto <D.32700>; else goto <D.32701>;
        <D.32700>:
        D.32702 = &MEM[(void *)"bool" + 3B];
        D.32703 = *D.32702;
        D.32704 = (int) D.32703;
        D.32705 = __s2 + 3;
        D.32706 = *D.32705;
        D.32707 = (int) D.32706;
        __result = D.32704 - D.32707;
        <D.32701>:
        <D.32699>:
        <D.32691>:
        <D.32689>:
        <D.32681>:
        <D.32679>:
      }
      D.25138 = __result;
    }
    iftmp.338 = -D.25138;
    goto <D.32708>;
    <D.32672>:
    iftmp.338 = __builtin_strcmp (typename, "bool");
    <D.32708>:
    D.25139 = iftmp.338;
  }
  if (D.25139 == 0) goto <D.32709>; else goto <D.32710>;
  <D.32709>:
  klass = mono_defaults.boolean_class;
  goto <D.32711>;
  <D.32710>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = typename;
      D.32715 = "boolean";
      D.32716 = MEM[(const unsigned char *)D.32715];
      D.32717 = (int) D.32716;
      D.32718 = *__s2;
      D.32719 = (int) D.32718;
      __result = D.32717 - D.32719;
      {
        if (__s2_len != 0) goto <D.32720>; else goto <D.32721>;
        <D.32720>:
        if (__result == 0) goto <D.32722>; else goto <D.32723>;
        <D.32722>:
        D.32724 = &MEM[(void *)"boolean" + 1B];
        D.32725 = *D.32724;
        D.32726 = (int) D.32725;
        D.32727 = __s2 + 1;
        D.32728 = *D.32727;
        D.32729 = (int) D.32728;
        __result = D.32726 - D.32729;
        if (__s2_len > 1) goto <D.32730>; else goto <D.32731>;
        <D.32730>:
        if (__result == 0) goto <D.32732>; else goto <D.32733>;
        <D.32732>:
        D.32734 = &MEM[(void *)"boolean" + 2B];
        D.32735 = *D.32734;
        D.32736 = (int) D.32735;
        D.32737 = __s2 + 2;
        D.32738 = *D.32737;
        D.32739 = (int) D.32738;
        __result = D.32736 - D.32739;
        if (__s2_len > 2) goto <D.32740>; else goto <D.32741>;
        <D.32740>:
        if (__result == 0) goto <D.32742>; else goto <D.32743>;
        <D.32742>:
        D.32744 = &MEM[(void *)"boolean" + 3B];
        D.32745 = *D.32744;
        D.32746 = (int) D.32745;
        D.32747 = __s2 + 3;
        D.32748 = *D.32747;
        D.32749 = (int) D.32748;
        __result = D.32746 - D.32749;
        <D.32743>:
        <D.32741>:
        <D.32733>:
        <D.32731>:
        <D.32723>:
        <D.32721>:
      }
      D.25147 = __result;
    }
    iftmp.339 = -D.25147;
    goto <D.32750>;
    <D.32714>:
    iftmp.339 = __builtin_strcmp (typename, "boolean");
    <D.32750>:
    D.25148 = iftmp.339;
  }
  if (D.25148 == 0) goto <D.32751>; else goto <D.32752>;
  <D.32751>:
  klass = mono_defaults.boolean_class;
  goto <D.32753>;
  <D.32752>:
  monoeg_g_log (0B, 4, "%s", typename);
  <D.25149>:
  goto <D.25149>;
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "icall.c", 8265);
  <D.32753>:
  <D.32711>:
  <D.32669>:
  <D.32627>:
  <D.32585>:
  <D.32543>:
  <D.32501>:
  <D.32459>:
  <D.32417>:
  <D.32375>:
  <D.32333>:
  <D.32291>:
  <D.32249>:
  <D.32207>:
  <D.32165>:
  <D.32123>:
  <D.32081>:
  <D.32039>:
  D.32754 = &klass->byval_arg;
  return D.32754;
}


mono_find_jit_icall_by_name (const char * name)
{
  struct GHashTable * jit_icall_hash_name.340;
  _Bool D.32757;
  long int D.32758;
  long int D.32759;
  struct MonoJitICallInfo * D.32762;
  struct MonoJitICallInfo * info;

  jit_icall_hash_name.340 = jit_icall_hash_name;
  D.32757 = jit_icall_hash_name.340 == 0B;
  D.32758 = (long int) D.32757;
  D.32759 = __builtin_expect (D.32758, 0);
  if (D.32759 != 0) goto <D.32760>; else goto <D.32761>;
  <D.32760>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "icall.c", 8331, "jit_icall_hash_name");
  <D.32761>:
  mono_icall_lock ();
  jit_icall_hash_name.340 = jit_icall_hash_name;
  info = monoeg_g_hash_table_lookup (jit_icall_hash_name.340, name);
  mono_icall_unlock ();
  D.32762 = info;
  return D.32762;
}


mono_find_jit_icall_by_addr (const void * addr)
{
  struct GHashTable * jit_icall_hash_addr.341;
  _Bool D.32765;
  long int D.32766;
  long int D.32767;
  struct MonoJitICallInfo * D.32770;
  struct MonoJitICallInfo * info;

  jit_icall_hash_addr.341 = jit_icall_hash_addr;
  D.32765 = jit_icall_hash_addr.341 == 0B;
  D.32766 = (long int) D.32765;
  D.32767 = __builtin_expect (D.32766, 0);
  if (D.32767 != 0) goto <D.32768>; else goto <D.32769>;
  <D.32768>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "icall.c", 8343, "jit_icall_hash_addr");
  <D.32769>:
  mono_icall_lock ();
  jit_icall_hash_addr.341 = jit_icall_hash_addr;
  info = monoeg_g_hash_table_lookup (jit_icall_hash_addr.341, addr);
  mono_icall_unlock ();
  D.32770 = info;
  return D.32770;
}


mono_get_jit_icall_info ()
{
  struct GHashTable * D.32772;

  D.32772 = jit_icall_hash_name;
  return D.32772;
}


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

  res = 0B;
  mono_icall_lock ();
  jit_icall_hash_name.342 = jit_icall_hash_name;
  info = monoeg_g_hash_table_lookup (jit_icall_hash_name.342, name);
  if (info != 0B) goto <D.32775>; else goto <D.32776>;
  <D.32775>:
  res = info->c_symbol;
  <D.32776>:
  mono_icall_unlock ();
  D.32777 = res;
  return D.32777;
}


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

  mono_icall_lock ();
  jit_icall_hash_addr.343 = jit_icall_hash_addr;
  monoeg_g_hash_table_insert_replace (jit_icall_hash_addr.343, 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.32780;
  long int D.32781;
  long int D.32782;
  _Bool D.32785;
  long int D.32786;
  long int D.32787;
  struct GHashTable * jit_icall_hash_name.344;
  struct GHashTable * jit_icall_hash_name.345;
  struct GHashTable * jit_icall_hash_addr.346;
  void * D.32795;
  const char * D.32801;
  struct GHashTable * jit_icall_hash_addr.347;
  struct MonoJitICallInfo * D.32803;
  struct MonoJitICallInfo * info;

  D.32780 = func == 0B;
  D.32781 = (long int) D.32780;
  D.32782 = __builtin_expect (D.32781, 0);
  if (D.32782 != 0) goto <D.32783>; else goto <D.32784>;
  <D.32783>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "icall.c", 8396, "func");
  <D.32784>:
  D.32785 = name == 0B;
  D.32786 = (long int) D.32785;
  D.32787 = __builtin_expect (D.32786, 0);
  if (D.32787 != 0) goto <D.32788>; else goto <D.32789>;
  <D.32788>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "icall.c", 8397, "name");
  <D.32789>:
  mono_icall_lock ();
  jit_icall_hash_name.344 = jit_icall_hash_name;
  if (jit_icall_hash_name.344 == 0B) goto <D.32791>; else goto <D.32792>;
  <D.32791>:
  jit_icall_hash_name.345 = 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.345;
  jit_icall_hash_addr.346 = monoeg_g_hash_table_new (0B, 0B);
  jit_icall_hash_addr = jit_icall_hash_addr.346;
  <D.32792>:
  jit_icall_hash_name.344 = jit_icall_hash_name;
  D.32795 = monoeg_g_hash_table_lookup (jit_icall_hash_name.344, name);
  if (D.32795 != 0B) goto <D.32796>; else goto <D.32797>;
  <D.32796>:
  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.32797>:
  info = monoeg_malloc0 (24);
  info->name = name;
  info->func = func;
  info->sig = sig;
  info->c_symbol = c_symbol;
  if (is_save != 0) goto <D.32798>; else goto <D.32799>;
  <D.32798>:
  info->wrapper = func;
  goto <D.32800>;
  <D.32799>:
  info->wrapper = 0B;
  <D.32800>:
  jit_icall_hash_name.344 = jit_icall_hash_name;
  D.32801 = info->name;
  monoeg_g_hash_table_insert_replace (jit_icall_hash_name.344, D.32801, info, 0);
  jit_icall_hash_addr.347 = jit_icall_hash_addr;
  monoeg_g_hash_table_insert_replace (jit_icall_hash_addr.347, func, info, 0);
  mono_icall_unlock ();
  D.32803 = info;
  return D.32803;
}


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

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