mono_class_from_typeref (struct MonoImage * image, guint32 type_token)
{
  unsigned int D.21396;
  unsigned int D.21397;
  int D.21398;
  char * D.21401;
  const char * D.21402;
  struct MonoClass * D.21403;
  int D.21404;
  unsigned int D.21405;
  unsigned int D.21406;
  unsigned int D.21407;
  unsigned int D.21408;
  int idx.0;
  const char * iftmp.1;
  char D.21415;
  struct MonoAssembly * D.21419;
  struct MonoAssemblyName * D.21420;
  gchar * D.21423;
  unsigned int D.21424;
  long unsigned int D.21429;
  long unsigned int D.21430;
  struct MonoClassExt * D.21432;
  const char * D.21434;
  int D.21435;
  struct MonoImage * D.21438;
  unsigned int D.21439;
  unsigned int D.21440;
  struct MonoTableInfo * D.21441;
  int D.21442;
  struct MonoTableInfo * D.21443;
  unsigned int D.21444;
  int D.21445;
  int D.21446;
  unsigned int D.21449;
  int D.21450;
  int D.21453;
  unsigned int D.21454;
  unsigned int D.21455;
  <unnamed-unsigned:24> D.21457;
  unsigned int D.21458;
  gchar * D.21461;
  struct MonoAssembly * * D.21464;
  unsigned int D.21466;
  long unsigned int D.21467;
  long unsigned int D.21468;
  struct MonoAssembly * * D.21469;
  struct MonoAssembly * D.21470;
  int D.21471;
  _Bool D.21472;
  long int D.21473;
  long int D.21474;
  int iftmp.2;
  struct MonoImage * D.21483;
  struct MonoError error;
  guint32 cols[3];
  struct MonoTableInfo * t;
  guint32 idx;
  const char * name;
  const char * nspace;
  struct MonoClass * res;
  struct MonoImage * module;

  try
    {
      t = &image->tables[1];
      D.21396 = type_token & 16777215;
      D.21397 = D.21396 + 4294967295;
      D.21398 = mono_verifier_verify_typeref_row (image, D.21397, &error);
      if (D.21398 == 0) goto <D.21399>; else goto <D.21400>;
      <D.21399>:
      D.21401 = image->name;
      D.21402 = mono_error_get_message (&error);
      mono_trace (16, 2, "Failed to resolve typeref from %s due to \'%s\'", D.21401, D.21402);
      D.21403 = 0B;
      return D.21403;
      <D.21400>:
      D.21396 = type_token & 16777215;
      D.21397 = D.21396 + 4294967295;
      D.21404 = (int) D.21397;
      mono_metadata_decode_row (t, D.21404, &cols, 3);
      D.21405 = cols[1];
      name = mono_metadata_string_heap (image, D.21405);
      D.21406 = cols[2];
      nspace = mono_metadata_string_heap (image, D.21406);
      D.21407 = cols[0];
      idx = D.21407 >> 2;
      D.21407 = cols[0];
      D.21408 = D.21407 & 3;
      switch (D.21408) <default: <D.21456>, case 0: <D.18972>, case 1: <D.18974>, case 2: <D.18991>, case 3: <D.18977>>
      <D.18972>:
      if (idx == 0) goto <D.21409>; else goto <D.21410>;
      <D.21409>:
      monoeg_g_log (0B, 4, "null ResolutionScope not yet handled");
      <D.18973>:
      goto <D.18973>;
      <D.21410>:
      D.21403 = mono_class_from_name (image, nspace, name);
      return D.21403;
      <D.18974>:
      idx.0 = (int) idx;
      module = mono_image_load_module (image, idx.0);
      if (module != 0B) goto <D.21412>; else goto <D.21413>;
      <D.21412>:
      D.21403 = mono_class_from_name (module, nspace, name);
      return D.21403;
      <D.21413>:
      {
        char * msg;
        char * human_name;

        D.21415 = *nspace;
        if (D.21415 != 0) goto <D.21416>; else goto <D.21417>;
        <D.21416>:
        iftmp.1 = ".";
        goto <D.21418>;
        <D.21417>:
        iftmp.1 = "";
        <D.21418>:
        msg = monoeg_g_strdup_printf ("%s%s%s", nspace, iftmp.1, name);
        D.21419 = image->assembly;
        D.21420 = &D.21419->aname;
        human_name = mono_stringify_assembly_name (D.21420);
        mono_loader_set_error_type_load (msg, human_name);
        monoeg_g_free (msg);
        monoeg_g_free (human_name);
        D.21403 = 0B;
        return D.21403;
      }
      <D.18977>:
      {
        struct MonoClass * enclosing;
        struct GList * tmp;

        D.21396 = type_token & 16777215;
        if (D.21396 == idx) goto <D.21421>; else goto <D.21422>;
        <D.21421>:
        D.21401 = image->name;
        D.21423 = monoeg_g_strdup_printf ("Image %s with self-referencing typeref token %08x.", D.21401, type_token);
        mono_loader_set_error_bad_image (D.21423);
        D.21403 = 0B;
        return D.21403;
        <D.21422>:
        D.21424 = idx | 16777216;
        enclosing = mono_class_from_typeref (image, D.21424);
        if (enclosing == 0B) goto <D.21425>; else goto <D.21426>;
        <D.21425>:
        D.21403 = 0B;
        return D.21403;
        <D.21426>:
        D.21429 = BIT_FIELD_REF <*enclosing, 64, 256>;
        D.21430 = D.21429 & 4294967296;
        if (D.21430 != 0) goto <D.21431>; else goto <D.21427>;
        <D.21431>:
        D.21432 = enclosing->ext;
        if (D.21432 != 0B) goto <D.21433>; else goto <D.21427>;
        <D.21433>:
        D.21432 = enclosing->ext;
        tmp = D.21432->nested_classes;
        goto <D.18981>;
        <D.18980>:
        res = tmp->data;
        D.21434 = res->name;
        D.21435 = strcmp (D.21434, name);
        if (D.21435 == 0) goto <D.21436>; else goto <D.21437>;
        <D.21436>:
        D.21403 = res;
        return D.21403;
        <D.21437>:
        tmp = tmp->next;
        <D.18981>:
        if (tmp != 0B) goto <D.18980>; else goto <D.18982>;
        <D.18982>:
        goto <D.21428>;
        <D.21427>:
        {
          int i;

          D.21438 = enclosing->image;
          D.21439 = enclosing->type_token;
          D.21440 = mono_metadata_nesting_typedef (D.21438, D.21439, 1);
          i = (int) D.21440;
          goto <D.18989>;
          <D.18988>:
          {
            guint32 class_nested;
            guint32 string_offset;
            const char * nname;

            D.21438 = enclosing->image;
            D.21441 = &D.21438->tables[41];
            D.21442 = i + -1;
            class_nested = mono_metadata_decode_row_col (D.21441, D.21442, 0);
            D.21438 = enclosing->image;
            D.21443 = &D.21438->tables[2];
            D.21444 = class_nested + 4294967295;
            D.21445 = (int) D.21444;
            string_offset = mono_metadata_decode_row_col (D.21443, D.21445, 1);
            D.21438 = enclosing->image;
            nname = mono_metadata_string_heap (D.21438, string_offset);
            D.21446 = strcmp (nname, name);
            if (D.21446 == 0) goto <D.21447>; else goto <D.21448>;
            <D.21447>:
            {
              struct MonoClass * res;

              D.21438 = enclosing->image;
              D.21449 = class_nested | 33554432;
              res = mono_class_create_from_typedef (D.21438, D.21449, &error);
              D.21450 = mono_error_ok (&error);
              if (D.21450 == 0) goto <D.21451>; else goto <D.21452>;
              <D.21451>:
              mono_loader_set_error_from_mono_error (&error);
              mono_error_cleanup (&error);
              D.21403 = 0B;
              return D.21403;
              <D.21452>:
              D.21403 = res;
              return D.21403;
            }
            <D.21448>:
            D.21438 = enclosing->image;
            D.21439 = enclosing->type_token;
            D.21453 = i + 1;
            D.21454 = (unsigned int) D.21453;
            D.21455 = mono_metadata_nesting_typedef (D.21438, D.21439, D.21454);
            i = (int) D.21455;
          }
          <D.18989>:
          if (i != 0) goto <D.18988>; else goto <D.18990>;
          <D.18990>:
        }
        <D.21428>:
        D.21401 = image->name;
        monoeg_g_log (0B, 16, "TypeRef ResolutionScope not yet handled (%d) for %s.%s in image %s", idx, nspace, name, D.21401);
        D.21403 = 0B;
        return D.21403;
      }
      <D.18991>:
      goto <D.18992>;
      <D.21456>:
      <D.18992>:
      D.21457 = image->tables[35].rows;
      D.21458 = (unsigned int) D.21457;
      if (D.21458 < idx) goto <D.21459>; else goto <D.21460>;
      <D.21459>:
      D.21401 = image->name;
      D.21461 = monoeg_g_strdup_printf ("Image %s with invalid assemblyref token %08x.", D.21401, idx);
      mono_loader_set_error_bad_image (D.21461);
      D.21403 = 0B;
      return D.21403;
      <D.21460>:
      D.21464 = image->references;
      if (D.21464 == 0B) goto <D.21462>; else goto <D.21465>;
      <D.21465>:
      D.21464 = image->references;
      D.21466 = idx + 4294967295;
      D.21467 = (long unsigned int) D.21466;
      D.21468 = D.21467 * 8;
      D.21469 = D.21464 + D.21468;
      D.21470 = *D.21469;
      if (D.21470 == 0B) goto <D.21462>; else goto <D.21463>;
      <D.21462>:
      D.21466 = idx + 4294967295;
      D.21471 = (int) D.21466;
      mono_assembly_load_reference (image, D.21471);
      <D.21463>:
      D.21464 = image->references;
      D.21466 = idx + 4294967295;
      D.21467 = (long unsigned int) D.21466;
      D.21468 = D.21467 * 8;
      D.21469 = D.21464 + D.21468;
      D.21470 = *D.21469;
      D.21472 = D.21470 == 0B;
      D.21473 = (long int) D.21472;
      D.21474 = __builtin_expect (D.21473, 0);
      if (D.21474 != 0) goto <D.21475>; else goto <D.21476>;
      <D.21475>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "class.c", 248, "image->references [idx - 1]");
      <D.21476>:
      D.21464 = image->references;
      D.21466 = idx + 4294967295;
      D.21467 = (long unsigned int) D.21466;
      D.21468 = D.21467 * 8;
      D.21469 = D.21464 + D.21468;
      D.21470 = *D.21469;
      if (D.21470 == -1B) goto <D.21477>; else goto <D.21478>;
      <D.21477>:
      {
        struct MonoAssemblyName aname;
        char * human_name;

        try
          {
            D.21466 = idx + 4294967295;
            D.21471 = (int) D.21466;
            mono_assembly_get_assemblyref (image, D.21471, &aname);
            human_name = mono_stringify_assembly_name (&aname);
            D.21419 = image->assembly;
            if (D.21419 != 0B) goto <D.21480>; else goto <D.21481>;
            <D.21480>:
            D.21419 = image->assembly;
            iftmp.2 = D.21419->ref_only;
            goto <D.21482>;
            <D.21481>:
            iftmp.2 = 0;
            <D.21482>:
            mono_loader_set_error_assembly_load (human_name, iftmp.2);
            monoeg_g_free (human_name);
            D.21403 = 0B;
            return D.21403;
          }
        finally
          {
            aname = {CLOBBER};
          }
      }
      <D.21478>:
      D.21464 = image->references;
      D.21466 = idx + 4294967295;
      D.21467 = (long unsigned int) D.21466;
      D.21468 = D.21467 * 8;
      D.21469 = D.21464 + D.21468;
      D.21470 = *D.21469;
      D.21483 = D.21470->image;
      D.21403 = mono_class_from_name (D.21483, nspace, name);
      return D.21403;
    }
  finally
    {
      error = {CLOBBER};
      cols = {CLOBBER};
    }
}


__attribute__((__gnu_inline__, nothrow, leaf, pure))
strcmp (const char * __s1, const char * __s2)
{
  int iftmp.3;
  int iftmp.4;
  int D.21495;
  char * __p1;
  char * __p2;
  int __ret;

  __p1 = __s1;
  __p2 = __s2;
  __asm__ __volatile__("   slr   0,0
0: clst  %1,%2
   jo    0b
   ipm   %0
   srl   %0,28" : "=d" __ret, "=&a" __p1, "=&a" __p2 : "1" __p1, "2" __p2 : "0", "memory", "cc");
  if (__ret != 0) goto <D.21488>; else goto <D.21489>;
  <D.21488>:
  if (__ret == 1) goto <D.21491>; else goto <D.21492>;
  <D.21491>:
  iftmp.4 = -1;
  goto <D.21493>;
  <D.21492>:
  iftmp.4 = 1;
  <D.21493>:
  iftmp.3 = iftmp.4;
  goto <D.21494>;
  <D.21489>:
  iftmp.3 = 0;
  <D.21494>:
  __ret = iftmp.3;
  D.21495 = __ret;
  return D.21495;
}


mono_class_create_from_typedef (struct MonoImage * image, guint32 type_token, struct MonoError * error)
{
  unsigned int D.21499;
  <unnamed-unsigned:24> D.21501;
  unsigned int D.21502;
  struct MonoLoaderError * D.21503;
  _Bool D.21504;
  long int D.21505;
  long int D.21506;
  struct MonoClass * D.21509;
  struct MonoInternalHashTable * D.21510;
  long unsigned int D.21511;
  void * D.21512;
  struct MonoLoaderError * D.21515;
  _Bool D.21516;
  long int D.21517;
  long int D.21518;
  unsigned int D.21521;
  int D.21522;
  unsigned int D.21523;
  unsigned int D.21524;
  unsigned int D.21525;
  unsigned int classes_size.5;
  unsigned int D.21527;
  unsigned int D.21528;
  struct MonoGenericContainer * D.21529;
  struct MonoGenericContainer * D.21530;
  unsigned int D.21535;
  unsigned int D.21538;
  gchar * D.21543;
  struct MonoGenericClass * D.21548;
  struct MonoClass * D.21551;
  struct MonoClass * D.21558;
  int D.21559;
  const char * D.21562;
  gchar * D.21563;
  struct MonoLoaderError * D.21564;
  _Bool D.21565;
  long int D.21566;
  long int D.21567;
  unsigned int D.21570;
  unsigned int D.21571;
  struct MonoClass * D.21574;
  long unsigned int D.21575;
  long unsigned int D.21576;
  int D.21579;
  gchar * D.21582;
  struct MonoClass * * interfaces.6;
  unsigned int icount.7;
  short unsigned int D.21585;
  unsigned int D.21586;
  unsigned int D.21587;
  unsigned int D.21588;
  unsigned int D.21589;
  int tidx.8;
  unsigned int D.21593;
  unsigned int D.21594;
  <unnamed-unsigned:24> D.21596;
  <unnamed-unsigned:24> D.21597;
  unsigned int D.21601;
  unsigned int D.21603;
  unsigned int D.21604;
  unsigned int D.21605;
  unsigned int D.21608;
  unsigned int D.21609;
  int D.21611;
  int D.21614;
  int D.21617;
  int D.21620;
  unsigned int D.21621;
  unsigned int D.21622;
  int D.21623;
  unsigned int D.21624;
  _Bool D.21625;
  long int D.21626;
  long int D.21627;
  struct MonoClass * D.21634;
  struct MonoLoaderError * D.21635;
  _Bool D.21636;
  long int D.21637;
  long int D.21638;
  struct MonoClass * D.21641;
  int D.21644;
  gchar * D.21647;
  struct MonoLoaderError * D.21648;
  _Bool D.21649;
  long int D.21650;
  long int D.21651;
  struct MonoImage * D.21654;
  const char * D.21655;
  int D.21658;
  int D.21661;
  _Bool iftmp.9;
  long unsigned int D.21665;
  int D.21668;
  int D.21670;
  int iftmp.10;
  const char * D.21677;
  int D.21678;
  int D.21680;
  int D.21682;
  int D.21684;
  int D.21686;
  int D.21688;
  int D.21690;
  int D.21692;
  int D.21694;
  int D.21696;
  unsigned char D.21697;
  <unnamed-unsigned:1> D.21698;
  struct MonoLoaderError * D.21699;
  _Bool D.21700;
  long int D.21701;
  long int D.21702;
  struct MonoLoaderError * D.21705;
  _Bool D.21706;
  long int D.21707;
  long int D.21708;
  struct MonoTableInfo * tt;
  struct MonoClass * class;
  struct MonoClass * parent;
  guint32 cols[6];
  guint32 cols_next[6];
  guint tidx;
  struct MonoGenericContext * context;
  const char * name;
  const char * nspace;
  guint icount;
  struct MonoClass * * interfaces;
  guint32 field_last;
  guint32 method_last;
  guint32 nesting_tokeen;
  void parent_failure = <<< error >>>;

  try
    {
      tt = &image->tables[2];
      parent = 0B;
      tidx = type_token & 16777215;
      context = 0B;
      icount = 0;
      mono_error_init (error);
      D.21499 = type_token >> 24;
      if (D.21499 != 2) goto <D.21497>; else goto <D.21500>;
      <D.21500>:
      D.21501 = tt->rows;
      D.21502 = (unsigned int) D.21501;
      if (D.21502 < tidx) goto <D.21497>; else goto <D.21498>;
      <D.21497>:
      mono_error_set_bad_image (error, image, "Invalid typedef token %x", type_token);
      D.21503 = mono_loader_get_last_error ();
      D.21504 = D.21503 != 0B;
      D.21505 = (long int) D.21504;
      D.21506 = __builtin_expect (D.21505, 0);
      if (D.21506 != 0) goto <D.21507>; else goto <D.21508>;
      <D.21507>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "class.c", 5589, "!mono_loader_get_last_error ()");
      <D.21508>:
      D.21509 = 0B;
      return D.21509;
      <D.21498>:
      mono_loader_lock ();
      D.21510 = &image->class_cache;
      D.21511 = (long unsigned int) type_token;
      D.21512 = (void *) D.21511;
      class = mono_internal_hash_table_lookup (D.21510, D.21512);
      if (class != 0B) goto <D.21513>; else goto <D.21514>;
      <D.21513>:
      mono_loader_unlock ();
      D.21515 = mono_loader_get_last_error ();
      D.21516 = D.21515 != 0B;
      D.21517 = (long int) D.21516;
      D.21518 = __builtin_expect (D.21517, 0);
      if (D.21518 != 0) goto <D.21519>; else goto <D.21520>;
      <D.21519>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "class.c", 5597, "!mono_loader_get_last_error ()");
      <D.21520>:
      D.21509 = class;
      return D.21509;
      <D.21514>:
      D.21521 = tidx + 4294967295;
      D.21522 = (int) D.21521;
      mono_metadata_decode_row (tt, D.21522, &cols, 6);
      D.21523 = cols[1];
      name = mono_metadata_string_heap (image, D.21523);
      D.21524 = cols[2];
      nspace = mono_metadata_string_heap (image, D.21524);
      class = mono_image_alloc0 (image, 272);
      class->name = name;
      class->name_space = nspace;
      mono_profiler_class_event (class, 0);
      class->image = image;
      class->type_token = type_token;
      D.21525 = cols[0];
      class->flags = D.21525;
      D.21510 = &image->class_cache;
      D.21511 = (long unsigned int) type_token;
      D.21512 = (void *) D.21511;
      mono_internal_hash_table_insert (D.21510, D.21512, class);
      classes_size.5 = classes_size;
      D.21527 = classes_size.5 + 272;
      classes_size = D.21527;
      D.21528 = class->type_token;
      D.21529 = mono_metadata_load_generic_params (image, D.21528, 0B);
      class->generic_container = D.21529;
      D.21530 = class->generic_container;
      if (D.21530 != 0B) goto <D.21531>; else goto <D.21532>;
      <D.21531>:
      class->is_generic = 1;
      D.21530 = class->generic_container;
      D.21530->owner.klass = class;
      D.21530 = class->generic_container;
      context = &D.21530->context;
      <D.21532>:
      D.21530 = class->generic_container;
      if (D.21530 != 0B) goto <D.21533>; else goto <D.21534>;
      <D.21533>:
      enable_gclass_recording ();
      <D.21534>:
      D.21535 = cols[3];
      if (D.21535 != 0) goto <D.21536>; else goto <D.21537>;
      <D.21536>:
      {
        struct MonoClass * tmp;
        guint32 parent_token;

        D.21535 = cols[3];
        parent_token = mono_metadata_token_from_dor (D.21535);
        D.21538 = parent_token >> 24;
        if (D.21538 == 27) goto <D.21539>; else goto <D.21540>;
        <D.21539>:
        class->this_arg.byref = 1;
        class->this_arg.data.klass = class;
        class->this_arg.type = 18;
        class->byval_arg.data.klass = class;
        class->byval_arg.type = 18;
        <D.21540>:
        parent = mono_class_get_full (image, parent_token, context);
        if (parent == 0B) goto <D.21541>; else goto <D.21542>;
        <D.21541>:
        D.21543 = monoeg_g_strdup_printf ("Could not load parent, token is %x", parent_token);
        mono_class_set_failure_from_loader_error (class, error, D.21543);
        goto parent_failure;
        <D.21542>:
        tmp = parent;
        goto <D.20228>;
        <D.20227>:
        if (tmp == class) goto <D.21544>; else goto <D.21545>;
        <D.21544>:
        mono_class_set_failure_and_error (class, error, "Cycle found while resolving parent");
        goto parent_failure;
        <D.21545>:
        D.21530 = class->generic_container;
        if (D.21530 != 0B) goto <D.21546>; else goto <D.21547>;
        <D.21546>:
        D.21548 = tmp->generic_class;
        if (D.21548 != 0B) goto <D.21549>; else goto <D.21550>;
        <D.21549>:
        D.21548 = tmp->generic_class;
        D.21551 = D.21548->container_class;
        if (D.21551 == class) goto <D.21552>; else goto <D.21553>;
        <D.21552>:
        mono_class_set_failure_and_error (class, error, "Parent extends generic instance of this type");
        goto parent_failure;
        <D.21553>:
        <D.21550>:
        <D.21547>:
        tmp = tmp->parent;
        <D.20228>:
        if (tmp != 0B) goto <D.20227>; else goto <D.20229>;
        <D.20229>:
      }
      <D.21537>:
      mono_class_setup_parent (class, parent);
      mono_class_setup_mono_type (class);
      D.21530 = class->generic_container;
      if (D.21530 != 0B) goto <D.21554>; else goto <D.21555>;
      <D.21554>:
      disable_gclass_recording (fix_gclass_incomplete_instantiation, class);
      <D.21555>:
      nesting_tokeen = mono_metadata_nested_in_typedef (image, type_token);
      if (nesting_tokeen != 0) goto <D.21556>; else goto <D.21557>;
      <D.21556>:
      D.21558 = mono_class_create_from_typedef (image, nesting_tokeen, error);
      class->nested_in = D.21558;
      D.21559 = mono_error_ok (error);
      if (D.21559 == 0) goto <D.21560>; else goto <D.21561>;
      <D.21560>:
      D.21562 = mono_error_get_message (error);
      D.21563 = monoeg_strdup (D.21562);
      mono_class_set_failure (class, 7, D.21563);
      mono_loader_unlock ();
      mono_profiler_class_loaded (class, 1);
      D.21564 = mono_loader_get_last_error ();
      D.21565 = D.21564 != 0B;
      D.21566 = (long int) D.21565;
      D.21567 = __builtin_expect (D.21566, 0);
      if (D.21567 != 0) goto <D.21568>; else goto <D.21569>;
      <D.21568>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "class.c", 5684, "!mono_loader_get_last_error ()");
      <D.21569>:
      D.21509 = 0B;
      return D.21509;
      <D.21561>:
      <D.21557>:
      D.21570 = class->flags;
      D.21571 = D.21570 & 196608;
      if (D.21571 == 65536) goto <D.21572>; else goto <D.21573>;
      <D.21572>:
      class->unicode = 1;
      <D.21573>:
      class->element_class = class;
      D.21574 = class->element_class;
      class->cast_class = D.21574;
      D.21575 = BIT_FIELD_REF <*class, 64, 256>;
      D.21576 = D.21575 & 576460752303423488;
      if (D.21576 == 0) goto <D.21577>; else goto <D.21578>;
      <D.21577>:
      D.21579 = mono_metadata_interfaces_from_typedef_full (image, type_token, &interfaces, &icount, 0, context);
      if (D.21579 == 0) goto <D.21580>; else goto <D.21581>;
      <D.21580>:
      D.21582 = monoeg_strdup ("Could not load interfaces");
      mono_class_set_failure_from_loader_error (class, error, D.21582);
      mono_loader_unlock ();
      mono_profiler_class_loaded (class, 1);
      D.21509 = 0B;
      return D.21509;
      <D.21581>:
      interfaces.6 = interfaces;
      class->interfaces = interfaces.6;
      icount.7 = icount;
      D.21585 = (short unsigned int) icount.7;
      class->interface_count = D.21585;
      class->interfaces_inited = 1;
      <D.21578>:
      D.21586 = cols[4];
      D.21587 = D.21586 + 4294967295;
      class->field.first = D.21587;
      D.21588 = cols[5];
      D.21589 = D.21588 + 4294967295;
      class->method.first = D.21589;
      D.21501 = tt->rows;
      D.21502 = (unsigned int) D.21501;
      if (D.21502 > tidx) goto <D.21590>; else goto <D.21591>;
      <D.21590>:
      tidx.8 = (int) tidx;
      mono_metadata_decode_row (tt, tidx.8, &cols_next, 6);
      D.21593 = cols_next[4];
      field_last = D.21593 + 4294967295;
      D.21594 = cols_next[5];
      method_last = D.21594 + 4294967295;
      goto <D.21595>;
      <D.21591>:
      D.21596 = image->tables[4].rows;
      field_last = (guint32) D.21596;
      D.21597 = image->tables[6].rows;
      method_last = (guint32) D.21597;
      <D.21595>:
      D.21586 = cols[4];
      if (D.21586 != 0) goto <D.21600>; else goto <D.21598>;
      <D.21600>:
      D.21586 = cols[4];
      D.21596 = image->tables[4].rows;
      D.21601 = (unsigned int) D.21596;
      if (D.21586 <= D.21601) goto <D.21602>; else goto <D.21598>;
      <D.21602>:
      D.21603 = class->field.first;
      D.21604 = field_last - D.21603;
      class->field.count = D.21604;
      goto <D.21599>;
      <D.21598>:
      class->field.count = 0;
      <D.21599>:
      D.21588 = cols[5];
      D.21597 = image->tables[6].rows;
      D.21605 = (unsigned int) D.21597;
      if (D.21588 <= D.21605) goto <D.21606>; else goto <D.21607>;
      <D.21606>:
      D.21608 = class->method.first;
      D.21609 = method_last - D.21608;
      class->method.count = D.21609;
      goto <D.21610>;
      <D.21607>:
      class->method.count = 0;
      <D.21610>:
      D.21611 = mono_is_corlib_image (image);
      if (D.21611 != 0) goto <D.21612>; else goto <D.21613>;
      <D.21612>:
      D.21614 = strcmp (nspace, "System");
      if (D.21614 == 0) goto <D.21615>; else goto <D.21616>;
      <D.21615>:
      D.21617 = strcmp (name, "Array");
      if (D.21617 == 0) goto <D.21618>; else goto <D.21619>;
      <D.21618>:
      D.21620 = class->instance_size;
      D.21621 = (unsigned int) D.21620;
      D.21622 = D.21621 + 16;
      D.21623 = (int) D.21622;
      class->instance_size = D.21623;
      D.21624 = class->field.count;
      D.21625 = D.21624 != 0;
      D.21626 = (long int) D.21625;
      D.21627 = __builtin_expect (D.21626, 0);
      if (D.21627 != 0) goto <D.21628>; else goto <D.21629>;
      <D.21628>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "class.c", 5744, "class->field.count == 0");
      <D.21629>:
      <D.21619>:
      <D.21616>:
      <D.21613>:
      D.21575 = BIT_FIELD_REF <*class, 64, 256>;
      D.21576 = D.21575 & 576460752303423488;
      if (D.21576 != 0) goto <D.21630>; else goto <D.21631>;
      <D.21630>:
      {
        struct MonoType * enum_basetype;

        enum_basetype = mono_class_find_enum_basetype (class);
        if (enum_basetype == 0B) goto <D.21632>; else goto <D.21633>;
        <D.21632>:
        D.21634 = mono_defaults.int32_class;
        class->element_class = D.21634;
        D.21574 = class->element_class;
        class->cast_class = D.21574;
        mono_class_set_failure_and_error (class, error, "Could not enum basetype");
        mono_loader_unlock ();
        mono_profiler_class_loaded (class, 1);
        D.21635 = mono_loader_get_last_error ();
        D.21636 = D.21635 != 0B;
        D.21637 = (long int) D.21636;
        D.21638 = __builtin_expect (D.21637, 0);
        if (D.21638 != 0) goto <D.21639>; else goto <D.21640>;
        <D.21639>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "class.c", 5755, "!mono_loader_get_last_error ()");
        <D.21640>:
        D.21509 = 0B;
        return D.21509;
        <D.21633>:
        D.21641 = mono_class_from_mono_type (enum_basetype);
        class->element_class = D.21641;
        D.21574 = class->element_class;
        class->cast_class = D.21574;
      }
      <D.21631>:
      D.21530 = class->generic_container;
      if (D.21530 != 0B) goto <D.21642>; else goto <D.21643>;
      <D.21642>:
      D.21530 = class->generic_container;
      D.21644 = mono_metadata_load_generic_param_constraints_full (image, type_token, D.21530);
      if (D.21644 == 0) goto <D.21645>; else goto <D.21646>;
      <D.21645>:
      D.21647 = monoeg_strdup ("Could not load generic parameter constraints");
      mono_class_set_failure_from_loader_error (class, error, D.21647);
      mono_loader_unlock ();
      mono_profiler_class_loaded (class, 1);
      D.21648 = mono_loader_get_last_error ();
      D.21649 = D.21648 != 0B;
      D.21650 = (long int) D.21649;
      D.21651 = __builtin_expect (D.21650, 0);
      if (D.21651 != 0) goto <D.21652>; else goto <D.21653>;
      <D.21652>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "class.c", 5770, "!mono_loader_get_last_error ()");
      <D.21653>:
      D.21509 = 0B;
      return D.21509;
      <D.21646>:
      <D.21643>:
      D.21654 = class->image;
      D.21655 = D.21654->assembly_name;
      if (D.21655 != 0B) goto <D.21656>; else goto <D.21657>;
      <D.21656>:
      D.21654 = class->image;
      D.21655 = D.21654->assembly_name;
      D.21658 = strcmp (D.21655, "Mono.Simd");
      if (D.21658 == 0) goto <D.21659>; else goto <D.21660>;
      <D.21659>:
      D.21661 = strcmp (nspace, "Mono.Simd");
      if (D.21661 == 0) goto <D.21662>; else goto <D.21663>;
      <D.21662>:
      D.21665 = __strlen_g ("Vector");
      if (D.21665 <= 5) goto <D.21666>; else goto <D.21667>;
      <D.21666>:
      D.21668 = strcmp (name, "Vector");
      iftmp.9 = D.21668 == 0;
      goto <D.21669>;
      <D.21667>:
      D.21670 = strncmp (name, "Vector", 6);
      iftmp.9 = D.21670 == 0;
      <D.21669>:
      if (iftmp.9 != 0) goto <D.21671>; else goto <D.21672>;
      <D.21671>:
      D.21677 = name + 6;
      D.21678 = strcmp (D.21677, "2d");
      if (D.21678 == 0) goto <D.21674>; else goto <D.21679>;
      <D.21679>:
      D.21677 = name + 6;
      D.21680 = strcmp (D.21677, "2ul");
      if (D.21680 == 0) goto <D.21674>; else goto <D.21681>;
      <D.21681>:
      D.21677 = name + 6;
      D.21682 = strcmp (D.21677, "2l");
      if (D.21682 == 0) goto <D.21674>; else goto <D.21683>;
      <D.21683>:
      D.21677 = name + 6;
      D.21684 = strcmp (D.21677, "4f");
      if (D.21684 == 0) goto <D.21674>; else goto <D.21685>;
      <D.21685>:
      D.21677 = name + 6;
      D.21686 = strcmp (D.21677, "4ui");
      if (D.21686 == 0) goto <D.21674>; else goto <D.21687>;
      <D.21687>:
      D.21677 = name + 6;
      D.21688 = strcmp (D.21677, "4i");
      if (D.21688 == 0) goto <D.21674>; else goto <D.21689>;
      <D.21689>:
      D.21677 = name + 6;
      D.21690 = strcmp (D.21677, "8s");
      if (D.21690 == 0) goto <D.21674>; else goto <D.21691>;
      <D.21691>:
      D.21677 = name + 6;
      D.21692 = strcmp (D.21677, "8us");
      if (D.21692 == 0) goto <D.21674>; else goto <D.21693>;
      <D.21693>:
      D.21677 = name + 6;
      D.21694 = strcmp (D.21677, "16b");
      if (D.21694 == 0) goto <D.21674>; else goto <D.21695>;
      <D.21695>:
      D.21677 = name + 6;
      D.21696 = strcmp (D.21677, "16sb");
      if (D.21696 == 0) goto <D.21674>; else goto <D.21675>;
      <D.21674>:
      iftmp.10 = 1;
      goto <D.21676>;
      <D.21675>:
      iftmp.10 = 0;
      <D.21676>:
      D.21697 = (unsigned char) iftmp.10;
      D.21698 = (<unnamed-unsigned:1>) D.21697;
      class->simd_type = D.21698;
      <D.21672>:
      <D.21663>:
      <D.21660>:
      <D.21657>:
      mono_loader_unlock ();
      mono_profiler_class_loaded (class, 0);
      D.21699 = mono_loader_get_last_error ();
      D.21700 = D.21699 != 0B;
      D.21701 = (long int) D.21700;
      D.21702 = __builtin_expect (D.21701, 0);
      if (D.21702 != 0) goto <D.21703>; else goto <D.21704>;
      <D.21703>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "class.c", 5782, "!mono_loader_get_last_error ()");
      <D.21704>:
      D.21509 = class;
      return D.21509;
      parent_failure:
      mono_class_setup_mono_type (class);
      mono_loader_unlock ();
      mono_profiler_class_loaded (class, 1);
      D.21705 = mono_loader_get_last_error ();
      D.21706 = D.21705 != 0B;
      D.21707 = (long int) D.21706;
      D.21708 = __builtin_expect (D.21707, 0);
      if (D.21708 != 0) goto <D.21709>; else goto <D.21710>;
      <D.21709>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "class.c", 5790, "!mono_loader_get_last_error ()");
      <D.21710>:
      D.21509 = 0B;
      return D.21509;
    }
  finally
    {
      cols = {CLOBBER};
      cols_next = {CLOBBER};
      icount = {CLOBBER};
      interfaces = {CLOBBER};
    }
}


fix_gclass_incomplete_instantiation (struct MonoClass * gclass, void * user_data)
{
  struct MonoGenericClass * D.21713;
  struct MonoClass * D.21714;
  gboolean D.21717;
  struct MonoClass * D.21718;
  struct MonoClass * D.21721;
  struct MonoClass * gtd;

  gtd = user_data;
  D.21713 = gclass->generic_class;
  D.21714 = D.21713->container_class;
  if (D.21714 != gtd) goto <D.21715>; else goto <D.21716>;
  <D.21715>:
  D.21717 = 0;
  return D.21717;
  <D.21716>:
  D.21718 = gtd->parent;
  if (D.21718 != 0B) goto <D.21719>; else goto <D.21720>;
  <D.21719>:
  D.21721 = gclass->parent;
  if (D.21721 == 0B) goto <D.21722>; else goto <D.21723>;
  <D.21722>:
  mono_generic_class_setup_parent (gclass, gtd);
  <D.21723>:
  <D.21720>:
  D.21717 = 1;
  return D.21717;
}


mono_generic_class_setup_parent (struct MonoClass * klass, struct MonoClass * gtd)
{
  struct MonoClass * D.21725;
  struct MonoGenericContext * D.21728;
  struct MonoClass * D.21729;
  int D.21730;
  struct MonoClass * D.21733;
  struct MonoClass * D.21734;
  long unsigned int D.21737;
  long unsigned int D.21738;
  struct MonoClass * D.21741;
  struct MonoClass * D.21742;

  D.21725 = gtd->parent;
  if (D.21725 != 0B) goto <D.21726>; else goto <D.21727>;
  <D.21726>:
  {
    struct MonoError error;
    struct MonoGenericClass * gclass;

    try
      {
        gclass = klass->generic_class;
        D.21725 = gtd->parent;
        D.21728 = mono_generic_class_get_context (gclass);
        D.21729 = mono_class_inflate_generic_class_checked (D.21725, D.21728, &error);
        klass->parent = D.21729;
        D.21730 = mono_error_ok (&error);
        if (D.21730 == 0) goto <D.21731>; else goto <D.21732>;
        <D.21731>:
        D.21733 = mono_defaults.object_class;
        klass->parent = D.21733;
        mono_class_set_failure (klass, 7, 0B);
        mono_error_cleanup (&error);
        <D.21732>:
      }
    finally
      {
        error = {CLOBBER};
      }
  }
  <D.21727>:
  D.21734 = klass->parent;
  if (D.21734 != 0B) goto <D.21735>; else goto <D.21736>;
  <D.21735>:
  D.21734 = klass->parent;
  mono_class_setup_parent (klass, D.21734);
  <D.21736>:
  D.21737 = BIT_FIELD_REF <*klass, 64, 256>;
  D.21738 = D.21737 & 576460752303423488;
  if (D.21738 != 0) goto <D.21739>; else goto <D.21740>;
  <D.21739>:
  D.21741 = gtd->cast_class;
  klass->cast_class = D.21741;
  D.21742 = gtd->element_class;
  klass->element_class = D.21742;
  <D.21740>:
}


mono_class_inflate_generic_class_checked (struct MonoClass * gklass, struct MonoGenericContext * context, struct MonoError * error)
{
  struct MonoType * D.21743;
  int D.21744;
  struct MonoClass * D.21747;
  struct MonoClass * res;
  struct MonoType * inflated;

  D.21743 = &gklass->byval_arg;
  inflated = mono_class_inflate_generic_type_checked (D.21743, context, error);
  D.21744 = mono_error_ok (error);
  if (D.21744 == 0) goto <D.21745>; else goto <D.21746>;
  <D.21745>:
  D.21747 = 0B;
  return D.21747;
  <D.21746>:
  res = mono_class_from_mono_type (inflated);
  mono_metadata_free_type (inflated);
  D.21747 = res;
  return D.21747;
}


enable_gclass_recording ()
{
  int record_gclass_instantiation.11;
  int D.21750;

  record_gclass_instantiation.11 = record_gclass_instantiation;
  D.21750 = record_gclass_instantiation.11 + 1;
  record_gclass_instantiation = D.21750;
}


disable_gclass_recording (gboolean (*gclass_record_func) (struct MonoClass *, void *) func, void * user_data)
{
  int record_gclass_instantiation.12;
  _Bool D.21752;
  long int D.21753;
  long int D.21754;
  int D.21757;
  void * D.21758;
  int D.21759;
  struct GSList * D.21762;
  struct GSList * D.21764;
  struct GSList * gclass_recorded_list.13;
  struct GSList * * head;

  head = &gclass_recorded_list;
  record_gclass_instantiation.12 = record_gclass_instantiation;
  D.21752 = record_gclass_instantiation.12 <= 0;
  D.21753 = (long int) D.21752;
  D.21754 = __builtin_expect (D.21753, 0);
  if (D.21754 != 0) goto <D.21755>; else goto <D.21756>;
  <D.21755>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "class.c", 120, "record_gclass_instantiation > 0");
  <D.21756>:
  record_gclass_instantiation.12 = record_gclass_instantiation;
  D.21757 = record_gclass_instantiation.12 + -1;
  record_gclass_instantiation = D.21757;
  goto <D.18958>;
  <D.18957>:
  {
    struct GSList * node;

    node = *head;
    D.21758 = node->data;
    D.21759 = func (D.21758, user_data);
    if (D.21759 != 0) goto <D.21760>; else goto <D.21761>;
    <D.21760>:
    D.21762 = node->next;
    *head = D.21762;
    monoeg_g_slist_free_1 (node);
    goto <D.21763>;
    <D.21761>:
    head = &node->next;
    <D.21763>:
  }
  <D.18958>:
  D.21764 = *head;
  if (D.21764 != 0B) goto <D.18957>; else goto <D.18959>;
  <D.18959>:
  record_gclass_instantiation.12 = record_gclass_instantiation;
  if (record_gclass_instantiation.12 == 0) goto <D.21765>; else goto <D.21766>;
  <D.21765>:
  gclass_recorded_list.13 = gclass_recorded_list;
  if (gclass_recorded_list.13 != 0B) goto <D.21768>; else goto <D.21769>;
  <D.21768>:
  gclass_recorded_list.13 = gclass_recorded_list;
  monoeg_g_slist_free (gclass_recorded_list.13);
  gclass_recorded_list = 0B;
  <D.21769>:
  <D.21766>:
}


mono_class_find_enum_basetype (struct MonoClass * class)
{
  unsigned int D.21770;
  long unsigned int D.21771;
  long unsigned int D.21772;
  _Bool D.21773;
  long int D.21774;
  long int D.21775;
  struct MonoGenericContainer * D.21778;
  struct MonoGenericClass * D.21782;
  _Bool D.21785;
  long int D.21786;
  long int D.21787;
  unsigned int D.21790;
  unsigned int i.14;
  unsigned int D.21792;
  unsigned int D.21793;
  unsigned int D.21794;
  struct MonoImage * D.21797;
  unsigned int D.21798;
  int D.21799;
  struct MonoType * D.21802;
  const char * sig.15;
  const char * sig.16;
  char D.21805;
  short int D.21808;
  const char * D.21809;
  struct MonoGenericContext * D.21814;
  short unsigned int D.21815;
  struct MonoGenericContainer * container;
  struct MonoImage * m;
  const int top;
  int i;

  container = 0B;
  m = class->image;
  D.21770 = class->field.count;
  top = (const int) D.21770;
  D.21771 = BIT_FIELD_REF <*class, 64, 256>;
  D.21772 = D.21771 & 576460752303423488;
  D.21773 = D.21772 == 0;
  D.21774 = (long int) D.21773;
  D.21775 = __builtin_expect (D.21774, 0);
  if (D.21775 != 0) goto <D.21776>; else goto <D.21777>;
  <D.21776>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "class.c", 1250, "class->enumtype");
  <D.21777>:
  D.21778 = class->generic_container;
  if (D.21778 != 0B) goto <D.21779>; else goto <D.21780>;
  <D.21779>:
  container = class->generic_container;
  goto <D.21781>;
  <D.21780>:
  D.21782 = class->generic_class;
  if (D.21782 != 0B) goto <D.21783>; else goto <D.21784>;
  <D.21783>:
  {
    struct MonoClass * gklass;

    D.21782 = class->generic_class;
    gklass = D.21782->container_class;
    container = gklass->generic_container;
    D.21785 = container == 0B;
    D.21786 = (long int) D.21785;
    D.21787 = __builtin_expect (D.21786, 0);
    if (D.21787 != 0) goto <D.21788>; else goto <D.21789>;
    <D.21788>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "class.c", 1258, "container");
    <D.21789>:
  }
  <D.21784>:
  <D.21781>:
  i = 0;
  goto <D.19253>;
  <D.19252>:
  {
    const char * sig;
    guint32 cols[3];
    int idx;
    struct MonoType * ftype;

    try
      {
        D.21790 = class->field.first;
        i.14 = (unsigned int) i;
        D.21792 = D.21790 + i.14;
        idx = (int) D.21792;
        mono_metadata_decode_table_row (m, 4, idx, &cols, 3);
        D.21793 = cols[0];
        D.21794 = D.21793 & 16;
        if (D.21794 != 0) goto <D.21795>; else goto <D.21796>;
        <D.21795>:
        // predicted unlikely by continue predictor.
        goto <D.19251>;
        <D.21796>:
        D.21797 = class->image;
        D.21798 = cols[2];
        D.21799 = mono_verifier_verify_field_signature (D.21797, D.21798, 0B);
        if (D.21799 == 0) goto <D.21800>; else goto <D.21801>;
        <D.21800>:
        D.21802 = 0B;
        return D.21802;
        <D.21801>:
        D.21798 = cols[2];
        sig.15 = mono_metadata_blob_heap (m, D.21798);
        sig = sig.15;
        sig.16 = sig;
        mono_metadata_decode_value (sig.16, &sig);
        sig.16 = sig;
        D.21805 = *sig.16;
        if (D.21805 != 6) goto <D.21806>; else goto <D.21807>;
        <D.21806>:
        D.21802 = 0B;
        return D.21802;
        <D.21807>:
        D.21793 = cols[0];
        D.21808 = (short int) D.21793;
        sig.16 = sig;
        D.21809 = sig.16 + 1;
        ftype = mono_metadata_parse_type_full (m, container, 5, D.21808, D.21809, &sig);
        if (ftype == 0B) goto <D.21810>; else goto <D.21811>;
        <D.21810>:
        D.21802 = 0B;
        return D.21802;
        <D.21811>:
        D.21782 = class->generic_class;
        if (D.21782 != 0B) goto <D.21812>; else goto <D.21813>;
        <D.21812>:
        D.21814 = mono_class_get_context (class);
        ftype = mono_class_inflate_generic_type (ftype, D.21814);
        D.21793 = cols[0];
        D.21815 = (short unsigned int) D.21793;
        ftype->attrs = D.21815;
        <D.21813>:
        D.21802 = ftype;
        return D.21802;
      }
    finally
      {
        sig = {CLOBBER};
        cols = {CLOBBER};
      }
  }
  <D.19251>:
  i = i + 1;
  <D.19253>:
  if (i < top) goto <D.19252>; else goto <D.19254>;
  <D.19254>:
  D.21802 = 0B;
  return D.21802;
}


mono_class_set_failure_and_error (struct MonoClass * class, struct MonoError * error, const char * msg)
{
  gchar * D.21819;

  D.21819 = monoeg_strdup (msg);
  mono_class_set_failure (class, 7, D.21819);
  mono_error_set_type_load_class (error, class, msg);
}


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

  if (str != 0B) goto <D.21820>; else goto <D.21821>;
  <D.21820>:
  D.21822 = __strdup (str);
  return D.21822;
  <D.21821>:
  D.21822 = 0B;
  return D.21822;
}


mono_class_set_failure_from_loader_error (struct MonoClass * class, struct MonoError * error, char * msg)
{
  struct MonoLoaderError * lerror;

  lerror = mono_loader_get_last_error ();
  if (lerror != 0B) goto <D.21824>; else goto <D.21825>;
  <D.21824>:
  set_failure_from_loader_error (class, lerror);
  mono_error_set_from_loader_error (error);
  if (msg != 0B) goto <D.21826>; else goto <D.21827>;
  <D.21826>:
  monoeg_g_free (msg);
  <D.21827>:
  goto <D.21828>;
  <D.21825>:
  mono_class_set_failure (class, 7, msg);
  mono_error_set_type_load_class (error, class, msg);
  <D.21828>:
}


set_failure_from_loader_error (struct MonoClass * class, struct MonoLoaderError * error)
{
  unsigned char D.21829;
  int D.21830;
  struct MonoImage * D.21831;
  char * D.21832;
  char * D.21833;
  const char * D.21834;
  struct MonoClass * D.21835;
  const char * D.21838;
  int D.21842;
  unsigned int D.21846;
  void * exception_data;

  exception_data = 0B;
  D.21829 = error->exception_type;
  D.21830 = (int) D.21829;
  switch (D.21830) <default: <D.20128>, case 5: <D.20121>, case 6: <D.20122>, case 7: <D.20119>, case 8: <D.20125>, case 12: <D.20127>>
  <D.20119>:
  D.21831 = class->image;
  D.21832 = error->class_name;
  D.21833 = error->assembly_name;
  exception_data = concat_two_strings_with_zero (D.21831, D.21832, D.21833);
  goto <D.20120>;
  <D.20121>:
  D.21831 = class->image;
  D.21832 = error->class_name;
  D.21834 = error->member_name;
  exception_data = concat_two_strings_with_zero (D.21831, D.21832, D.21834);
  goto <D.20120>;
  <D.20122>:
  {
    const char * name_space;
    const char * class_name;

    D.21835 = error->klass;
    name_space = D.21835->name_space;
    if (name_space != 0B) goto <D.21836>; else goto <D.21837>;
    <D.21836>:
    D.21835 = error->klass;
    D.21838 = D.21835->name;
    class_name = monoeg_g_strdup_printf ("%s.%s", name_space, D.21838);
    goto <D.21839>;
    <D.21837>:
    D.21835 = error->klass;
    class_name = D.21835->name;
    <D.21839>:
    D.21831 = class->image;
    D.21834 = error->member_name;
    exception_data = concat_two_strings_with_zero (D.21831, class_name, D.21834);
    if (name_space != 0B) goto <D.21840>; else goto <D.21841>;
    <D.21840>:
    monoeg_g_free (class_name);
    <D.21841>:
    goto <D.20120>;
  }
  <D.20125>:
  {
    const char * msg;

    D.21842 = error->ref_only;
    if (D.21842 != 0) goto <D.21843>; else goto <D.21844>;
    <D.21843>:
    msg = "Cannot resolve dependency to assembly \'%s\' because it has not been preloaded. When using the ReflectionOnly APIs, dependent assemblies must be pre-loaded or loaded on demand through the ReflectionOnlyAssemblyResolve event.";
    goto <D.21845>;
    <D.21844>:
    msg = "Could not load file or assembly \'%s\' or one of its dependencies.";
    <D.21845>:
    D.21831 = class->image;
    D.21833 = error->assembly_name;
    exception_data = concat_two_strings_with_zero (D.21831, msg, D.21833);
    goto <D.20120>;
  }
  <D.20127>:
  exception_data = error->msg;
  goto <D.20120>;
  <D.20128>:
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "class.c", 4891);
  <D.20120>:
  D.21829 = error->exception_type;
  D.21846 = (unsigned int) D.21829;
  mono_class_set_failure (class, D.21846, exception_data);
}


concat_two_strings_with_zero (struct MonoImage * image, const char * s1, const char * s2)
{
  long unsigned int D.21847;
  unsigned int iftmp.17;
  long unsigned int D.21851;
  unsigned int iftmp.18;
  long unsigned int D.21856;
  unsigned int D.21858;
  unsigned int D.21859;
  unsigned int len.19;
  long unsigned int D.21861;
  const char * iftmp.20;
  const char * iftmp.21;
  int D.21870;
  _Bool D.21871;
  long int D.21872;
  long int D.21873;
  char * D.21876;
  int null_length;
  int len;
  char * s;
  int result;

  D.21847 = __strlen_g ("(null)");
  null_length = (int) D.21847;
  if (s1 != 0B) goto <D.21849>; else goto <D.21850>;
  <D.21849>:
  D.21851 = __strlen_g (s1);
  iftmp.17 = (unsigned int) D.21851;
  goto <D.21852>;
  <D.21850>:
  iftmp.17 = (unsigned int) null_length;
  <D.21852>:
  if (s2 != 0B) goto <D.21854>; else goto <D.21855>;
  <D.21854>:
  D.21856 = __strlen_g (s2);
  iftmp.18 = (unsigned int) D.21856;
  goto <D.21857>;
  <D.21855>:
  iftmp.18 = (unsigned int) null_length;
  <D.21857>:
  D.21858 = iftmp.17 + iftmp.18;
  D.21859 = D.21858 + 2;
  len = (int) D.21859;
  len.19 = (unsigned int) len;
  s = mono_image_alloc (image, len.19);
  D.21861 = (long unsigned int) len;
  if (s1 != 0B) goto <D.21863>; else goto <D.21864>;
  <D.21863>:
  iftmp.20 = s1;
  goto <D.21865>;
  <D.21864>:
  iftmp.20 = "(null)";
  <D.21865>:
  if (s2 != 0B) goto <D.21867>; else goto <D.21868>;
  <D.21867>:
  iftmp.21 = s2;
  goto <D.21869>;
  <D.21868>:
  iftmp.21 = "(null)";
  <D.21869>:
  result = monoeg_g_snprintf (s, D.21861, "%s%c%s", iftmp.20, 0, iftmp.21);
  D.21870 = len + -1;
  D.21871 = D.21870 != result;
  D.21872 = (long int) D.21871;
  D.21873 = __builtin_expect (D.21872, 0);
  if (D.21873 != 0) goto <D.21874>; else goto <D.21875>;
  <D.21874>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "class.c", 4839, "result == len - 1");
  <D.21875>:
  D.21876 = s;
  return D.21876;
}


__attribute__((__gnu_inline__))
__strlen_g (const char * __str)
{
  size_t D.21878;
  long int __ptr.22;
  long int __str.23;
  long int D.21881;
  char * __ptr;
  char * __tmp;

  __ptr = 0B;
  __tmp = __str;
  __asm__ __volatile__("   la    0,0
0: srst  %0,%1
   jo    0b
" : "=&a" __ptr, "=&a" __tmp : "0" __ptr, "1" __tmp : "0", "memory", "cc");
  __ptr.22 = (long int) __ptr;
  __str.23 = (long int) __str;
  D.21881 = __ptr.22 - __str.23;
  D.21878 = (size_t) D.21881;
  return D.21878;
}


__attribute__((visibility ("hidden")))
mono_dup_array_type (struct MonoImage * image, struct MonoArrayType * a)
{
  int * D.21885;
  unsigned char D.21888;
  unsigned int D.21889;
  unsigned int D.21890;
  void * D.21891;
  int * D.21892;
  unsigned char D.21895;
  unsigned int D.21896;
  unsigned int D.21897;
  void * D.21898;
  void * D.21902;
  void * D.21905;
  struct MonoArrayType * D.21906;

  if (image != 0B) goto <D.21883>; else goto <D.21884>;
  <D.21883>:
  a = mono_image_memdup (image, a, 32);
  D.21885 = a->sizes;
  if (D.21885 != 0B) goto <D.21886>; else goto <D.21887>;
  <D.21886>:
  D.21885 = a->sizes;
  D.21888 = a->numsizes;
  D.21889 = (unsigned int) D.21888;
  D.21890 = D.21889 * 4;
  D.21891 = mono_image_memdup (image, D.21885, D.21890);
  a->sizes = D.21891;
  <D.21887>:
  D.21892 = a->lobounds;
  if (D.21892 != 0B) goto <D.21893>; else goto <D.21894>;
  <D.21893>:
  D.21892 = a->lobounds;
  D.21895 = a->numlobounds;
  D.21896 = (unsigned int) D.21895;
  D.21897 = D.21896 * 4;
  D.21898 = mono_image_memdup (image, D.21892, D.21897);
  a->lobounds = D.21898;
  <D.21894>:
  goto <D.21899>;
  <D.21884>:
  a = monoeg_g_memdup (a, 32);
  D.21885 = a->sizes;
  if (D.21885 != 0B) goto <D.21900>; else goto <D.21901>;
  <D.21900>:
  D.21885 = a->sizes;
  D.21888 = a->numsizes;
  D.21889 = (unsigned int) D.21888;
  D.21890 = D.21889 * 4;
  D.21902 = monoeg_g_memdup (D.21885, D.21890);
  a->sizes = D.21902;
  <D.21901>:
  D.21892 = a->lobounds;
  if (D.21892 != 0B) goto <D.21903>; else goto <D.21904>;
  <D.21903>:
  D.21892 = a->lobounds;
  D.21895 = a->numlobounds;
  D.21896 = (unsigned int) D.21895;
  D.21897 = D.21896 * 4;
  D.21905 = monoeg_g_memdup (D.21892, D.21897);
  a->lobounds = D.21905;
  <D.21904>:
  <D.21899>:
  D.21906 = a;
  return D.21906;
}


mono_image_memdup (struct MonoImage * image, void * data, guint size)
{
  long unsigned int D.21908;
  void * D.21909;
  void * res;

  res = mono_image_alloc (image, size);
  D.21908 = (long unsigned int) size;
  memcpy (res, data, D.21908);
  D.21909 = res;
  return D.21909;
}


__attribute__((__artificial__, __gnu_inline__, __always_inline__, __nothrow__, __leaf__))
memcpy (void * restrict __dest, const void * restrict __src, size_t __len)
{
  void * D.21911;
  long unsigned int D.21912;

  D.21912 = __builtin_object_size (__dest, 0);
  D.21911 = __builtin___memcpy_chk (__dest, __src, __len, D.21912);
  return D.21911;
}


__attribute__((visibility ("hidden")))
mono_metadata_signature_deep_dup (struct MonoImage * image, struct MonoMethodSignature * sig)
{
  struct MonoType * D.21914;
  struct MonoType * D.21915;
  struct MonoType * D.21916;
  struct MonoType * D.21917;
  short unsigned int D.21918;
  int D.21919;
  struct MonoMethodSignature * D.21920;
  int i;

  sig = mono_metadata_signature_dup_full (image, sig);
  D.21914 = sig->ret;
  D.21915 = mono_metadata_type_dup (image, D.21914);
  sig->ret = D.21915;
  i = 0;
  goto <D.19011>;
  <D.19010>:
  D.21916 = sig->params[i];
  D.21917 = mono_metadata_type_dup (image, D.21916);
  sig->params[i] = D.21917;
  i = i + 1;
  <D.19011>:
  D.21918 = sig->param_count;
  D.21919 = (int) D.21918;
  if (D.21919 > i) goto <D.19010>; else goto <D.19012>;
  <D.19012>:
  D.21920 = sig;
  return D.21920;
}


__attribute__((visibility ("hidden")))
mono_type_get_name_full (struct MonoType * type, MonoTypeNameFormat format)
{
  char * D.21922;
  struct GString * result;

  result = monoeg_g_string_new ("");
  mono_type_get_name_recurse (type, result, 0, format);
  D.21922 = monoeg_g_string_free (result, 0);
  return D.21922;
}


mono_type_get_name_recurse (struct MonoType * type, struct GString * str, gboolean is_recursed, MonoTypeNameFormat format)
{
  unsigned char D.21924;
  int D.21925;
  struct MonoArrayType * D.21926;
  unsigned char D.21927;
  MonoTypeNameFormat iftmp.24;
  struct MonoClass * D.21932;
  struct MonoType * D.21933;
  MonoTypeNameFormat iftmp.25;
  struct MonoClass * D.21942;
  struct MonoType * D.21943;
  MonoTypeNameFormat iftmp.26;
  struct MonoType * D.21950;
  struct MonoClass * D.21953;
  struct MonoGenericParam * D.21957;
  struct MonoGenericContainer * D.21958;
  struct MonoGenericParamInfo * D.21960;
  const char * iftmp.27;
  short unsigned int D.21965;
  int D.21966;
  struct MonoGenericParamInfo * iftmp.28;
  const char * D.21971;
  struct MonoClass * D.21972;
  struct MonoType * D.21975;
  const char * D.21980;
  char D.21981;
  const char * D.21986;
  int iftmp.29;
  long int s.30;
  long int D.21991;
  long int D.21992;
  long unsigned int D.21994;
  long int D.21995;
  struct MonoGenericClass * D.21998;
  MonoTypeNameFormat iftmp.31;
  unsigned char D.22012;
  struct MonoType * D.22017;
  <unnamed-unsigned:22> D.22024;
  int D.22025;
  struct MonoGenericContainer * D.22030;
  struct MonoGenericParamFull * D.22042;
  long unsigned int D.22043;
  long unsigned int D.22044;
  struct MonoGenericParamFull * D.22045;
  const char * D.22046;
  <unnamed-signed:31> D.22047;
  int D.22048;
  struct MonoClass * klass;

  D.21924 = type->type;
  D.21925 = (int) D.21924;
  switch (D.21925) <default: <D.19044>, case 15: <D.19040>, case 19: <D.19042>, case 20: <D.19030>, case 29: <D.19038>, case 30: <D.19043>>
  <D.19030>:
  {
    int i;
    int rank;
    MonoTypeNameFormat nested_format;

    D.21926 = type->data.array;
    D.21927 = D.21926->rank;
    rank = (int) D.21927;
    if (format != 3) goto <D.21929>; else goto <D.21930>;
    <D.21929>:
    iftmp.24 = format;
    goto <D.21931>;
    <D.21930>:
    iftmp.24 = 2;
    <D.21931>:
    nested_format = iftmp.24;
    D.21926 = type->data.array;
    D.21932 = D.21926->eklass;
    D.21933 = &D.21932->byval_arg;
    mono_type_get_name_recurse (D.21933, str, 0, nested_format);
    monoeg_g_string_append_c (str, 91);
    if (rank == 1) goto <D.21934>; else goto <D.21935>;
    <D.21934>:
    monoeg_g_string_append_c (str, 42);
    <D.21935>:
    i = 1;
    goto <D.19035>;
    <D.19034>:
    monoeg_g_string_append_c (str, 44);
    i = i + 1;
    <D.19035>:
    if (i < rank) goto <D.19034>; else goto <D.19036>;
    <D.19036>:
    monoeg_g_string_append_c (str, 93);
    mono_type_name_check_byref (type, str);
    if (format == 3) goto <D.21936>; else goto <D.21937>;
    <D.21936>:
    D.21926 = type->data.array;
    D.21932 = D.21926->eklass;
    _mono_type_get_assembly_name (D.21932, str);
    <D.21937>:
    goto <D.19037>;
  }
  <D.19038>:
  {
    MonoTypeNameFormat nested_format;

    if (format != 3) goto <D.21939>; else goto <D.21940>;
    <D.21939>:
    iftmp.25 = format;
    goto <D.21941>;
    <D.21940>:
    iftmp.25 = 2;
    <D.21941>:
    nested_format = iftmp.25;
    D.21942 = type->data.klass;
    D.21943 = &D.21942->byval_arg;
    mono_type_get_name_recurse (D.21943, str, 0, nested_format);
    monoeg_g_string_append (str, "[]");
    mono_type_name_check_byref (type, str);
    if (format == 3) goto <D.21944>; else goto <D.21945>;
    <D.21944>:
    D.21942 = type->data.klass;
    _mono_type_get_assembly_name (D.21942, str);
    <D.21945>:
    goto <D.19037>;
  }
  <D.19040>:
  {
    MonoTypeNameFormat nested_format;

    if (format != 3) goto <D.21947>; else goto <D.21948>;
    <D.21947>:
    iftmp.26 = format;
    goto <D.21949>;
    <D.21948>:
    iftmp.26 = 2;
    <D.21949>:
    nested_format = iftmp.26;
    D.21950 = type->data.type;
    mono_type_get_name_recurse (D.21950, str, 0, nested_format);
    monoeg_g_string_append_c (str, 42);
    mono_type_name_check_byref (type, str);
    if (format == 3) goto <D.21951>; else goto <D.21952>;
    <D.21951>:
    D.21950 = type->data.type;
    D.21953 = mono_class_from_mono_type (D.21950);
    _mono_type_get_assembly_name (D.21953, str);
    <D.21952>:
    goto <D.19037>;
  }
  <D.19042>:
  <D.19043>:
  D.21957 = type->data.generic_param;
  D.21958 = D.21957->owner;
  if (D.21958 == 0B) goto <D.21954>; else goto <D.21959>;
  <D.21959>:
  D.21957 = type->data.generic_param;
  D.21960 = &MEM[(struct MonoGenericParamFull *)D.21957].info;
  if (D.21960 == 0B) goto <D.21954>; else goto <D.21955>;
  <D.21954>:
  D.21924 = type->type;
  if (D.21924 == 19) goto <D.21962>; else goto <D.21963>;
  <D.21962>:
  iftmp.27 = "!";
  goto <D.21964>;
  <D.21963>:
  iftmp.27 = "!!";
  <D.21964>:
  D.21957 = type->data.generic_param;
  D.21965 = D.21957->num;
  D.21966 = (int) D.21965;
  monoeg_g_string_append_printf (str, "%s%d", iftmp.27, D.21966);
  goto <D.21956>;
  <D.21955>:
  D.21957 = type->data.generic_param;
  D.21958 = D.21957->owner;
  if (D.21958 != 0B) goto <D.21968>; else goto <D.21969>;
  <D.21968>:
  D.21957 = type->data.generic_param;
  iftmp.28 = &MEM[(struct MonoGenericParamFull *)D.21957].info;
  goto <D.21970>;
  <D.21969>:
  iftmp.28 = 0B;
  <D.21970>:
  D.21971 = iftmp.28->name;
  monoeg_g_string_append (str, D.21971);
  <D.21956>:
  mono_type_name_check_byref (type, str);
  goto <D.19037>;
  <D.19044>:
  klass = mono_class_from_mono_type (type);
  D.21972 = klass->nested_in;
  if (D.21972 != 0B) goto <D.21973>; else goto <D.21974>;
  <D.21973>:
  D.21972 = klass->nested_in;
  D.21975 = &D.21972->byval_arg;
  mono_type_get_name_recurse (D.21975, str, 1, format);
  if (format == 0) goto <D.21976>; else goto <D.21977>;
  <D.21976>:
  monoeg_g_string_append_c (str, 46);
  goto <D.21978>;
  <D.21977>:
  monoeg_g_string_append_c (str, 43);
  <D.21978>:
  goto <D.21979>;
  <D.21974>:
  D.21980 = klass->name_space;
  D.21981 = *D.21980;
  if (D.21981 != 0) goto <D.21982>; else goto <D.21983>;
  <D.21982>:
  D.21980 = klass->name_space;
  monoeg_g_string_append (str, D.21980);
  monoeg_g_string_append_c (str, 46);
  <D.21983>:
  <D.21979>:
  if (format == 0) goto <D.21984>; else goto <D.21985>;
  <D.21984>:
  {
    char * s;
    int len;

    D.21986 = klass->name;
    s = __builtin_strchr (D.21986, 96);
    if (s != 0B) goto <D.21988>; else goto <D.21989>;
    <D.21988>:
    s.30 = (long int) s;
    D.21986 = klass->name;
    D.21991 = (long int) D.21986;
    D.21992 = s.30 - D.21991;
    iftmp.29 = (int) D.21992;
    goto <D.21993>;
    <D.21989>:
    D.21986 = klass->name;
    D.21994 = __strlen_g (D.21986);
    iftmp.29 = (int) D.21994;
    <D.21993>:
    len = iftmp.29;
    D.21986 = klass->name;
    D.21995 = (long int) len;
    monoeg_g_string_append_len (str, D.21986, D.21995);
  }
  goto <D.21996>;
  <D.21985>:
  D.21986 = klass->name;
  monoeg_g_string_append (str, D.21986);
  <D.21996>:
  if (is_recursed != 0) goto <D.19037>; else goto <D.21997>;
  <D.21997>:
  D.21998 = klass->generic_class;
  if (D.21998 != 0B) goto <D.21999>; else goto <D.22000>;
  <D.21999>:
  {
    struct MonoGenericClass * gclass;
    struct MonoGenericInst * inst;
    MonoTypeNameFormat nested_format;
    int i;

    gclass = klass->generic_class;
    inst = gclass->context.class_inst;
    if (format != 2) goto <D.22002>; else goto <D.22003>;
    <D.22002>:
    iftmp.31 = format;
    goto <D.22004>;
    <D.22003>:
    iftmp.31 = 3;
    <D.22004>:
    nested_format = iftmp.31;
    if (format == 0) goto <D.22005>; else goto <D.22006>;
    <D.22005>:
    monoeg_g_string_append_c (str, 60);
    goto <D.22007>;
    <D.22006>:
    monoeg_g_string_append_c (str, 91);
    <D.22007>:
    i = 0;
    goto <D.19053>;
    <D.19052>:
    {
      struct MonoType * t;

      t = inst->type_argv[i];
      if (i != 0) goto <D.22008>; else goto <D.22009>;
      <D.22008>:
      monoeg_g_string_append_c (str, 44);
      <D.22009>:
      if (nested_format == 3) goto <D.22010>; else goto <D.22011>;
      <D.22010>:
      D.22012 = t->type;
      if (D.22012 != 19) goto <D.22013>; else goto <D.22014>;
      <D.22013>:
      D.21924 = type->type;
      if (D.21924 != 30) goto <D.22015>; else goto <D.22016>;
      <D.22015>:
      monoeg_g_string_append_c (str, 91);
      <D.22016>:
      <D.22014>:
      <D.22011>:
      D.22017 = inst->type_argv[i];
      mono_type_get_name_recurse (D.22017, str, 0, nested_format);
      if (nested_format == 3) goto <D.22018>; else goto <D.22019>;
      <D.22018>:
      D.22012 = t->type;
      if (D.22012 != 19) goto <D.22020>; else goto <D.22021>;
      <D.22020>:
      D.21924 = type->type;
      if (D.21924 != 30) goto <D.22022>; else goto <D.22023>;
      <D.22022>:
      monoeg_g_string_append_c (str, 93);
      <D.22023>:
      <D.22021>:
      <D.22019>:
    }
    i = i + 1;
    <D.19053>:
    D.22024 = inst->type_argc;
    D.22025 = (int) D.22024;
    if (D.22025 > i) goto <D.19052>; else goto <D.19054>;
    <D.19054>:
    if (format == 0) goto <D.22026>; else goto <D.22027>;
    <D.22026>:
    monoeg_g_string_append_c (str, 62);
    goto <D.22028>;
    <D.22027>:
    monoeg_g_string_append_c (str, 93);
    <D.22028>:
  }
  goto <D.22029>;
  <D.22000>:
  D.22030 = klass->generic_container;
  if (D.22030 != 0B) goto <D.22031>; else goto <D.22032>;
  <D.22031>:
  if (format != 2) goto <D.22033>; else goto <D.22034>;
  <D.22033>:
  if (format != 3) goto <D.22035>; else goto <D.22036>;
  <D.22035>:
  {
    int i;

    if (format == 0) goto <D.22037>; else goto <D.22038>;
    <D.22037>:
    monoeg_g_string_append_c (str, 60);
    goto <D.22039>;
    <D.22038>:
    monoeg_g_string_append_c (str, 91);
    <D.22039>:
    i = 0;
    goto <D.19057>;
    <D.19056>:
    if (i != 0) goto <D.22040>; else goto <D.22041>;
    <D.22040>:
    monoeg_g_string_append_c (str, 44);
    <D.22041>:
    D.22030 = klass->generic_container;
    D.22042 = D.22030->type_params;
    D.22043 = (long unsigned int) i;
    D.22044 = D.22043 * 56;
    D.22045 = D.22042 + D.22044;
    D.22046 = D.22045->info.name;
    monoeg_g_string_append (str, D.22046);
    i = i + 1;
    <D.19057>:
    D.22030 = klass->generic_container;
    D.22047 = D.22030->type_argc;
    D.22048 = (int) D.22047;
    if (D.22048 > i) goto <D.19056>; else goto <D.19058>;
    <D.19058>:
    if (format == 0) goto <D.22049>; else goto <D.22050>;
    <D.22049>:
    monoeg_g_string_append_c (str, 62);
    goto <D.22051>;
    <D.22050>:
    monoeg_g_string_append_c (str, 93);
    <D.22051>:
  }
  <D.22036>:
  <D.22034>:
  <D.22032>:
  <D.22029>:
  mono_type_name_check_byref (type, str);
  if (format == 3) goto <D.22052>; else goto <D.22053>;
  <D.22052>:
  D.21924 = type->type;
  if (D.21924 != 19) goto <D.22054>; else goto <D.22055>;
  <D.22054>:
  D.21924 = type->type;
  if (D.21924 != 30) goto <D.22056>; else goto <D.22057>;
  <D.22056>:
  _mono_type_get_assembly_name (klass, str);
  <D.22057>:
  <D.22055>:
  <D.22053>:
  goto <D.19037>;
  <D.19037>:
}


mono_type_name_check_byref (struct MonoType * type, struct GString * str)
{
  long unsigned int D.22058;
  long unsigned int D.22059;

  D.22058 = BIT_FIELD_REF <*type, 64, 64>;
  D.22059 = D.22058 & 8589934592;
  if (D.22059 != 0) goto <D.22060>; else goto <D.22061>;
  <D.22060>:
  monoeg_g_string_append_c (str, 38);
  <D.22061>:
}


_mono_type_get_assembly_name (struct MonoClass * klass, struct GString * str)
{
  struct MonoImage * D.22062;
  struct MonoAssemblyName * D.22063;
  struct MonoAssembly * ta;
  char * name;

  D.22062 = klass->image;
  ta = D.22062->assembly;
  D.22063 = &ta->aname;
  name = mono_stringify_assembly_name (D.22063);
  monoeg_g_string_append_printf (str, ", %s", name);
  monoeg_g_free (name);
}


__attribute__((visibility ("hidden")))
mono_type_get_full_name (struct MonoClass * class)
{
  char * D.22064;
  struct MonoType * D.22065;

  D.22065 = mono_class_get_type (class);
  D.22064 = mono_type_get_name_full (D.22065, 1);
  return D.22064;
}


mono_type_get_name (struct MonoType * type)
{
  char * D.22067;

  D.22067 = mono_type_get_name_full (type, 0);
  return D.22067;
}


mono_type_get_underlying_type (struct MonoType * type)
{
  unsigned char D.22069;
  struct MonoClass * D.22072;
  long unsigned int D.22073;
  long unsigned int D.22074;
  long unsigned int D.22077;
  long unsigned int D.22078;
  struct MonoType * D.22081;
  struct MonoGenericClass * D.22084;
  struct MonoClass * D.22085;
  long unsigned int D.22086;
  long unsigned int D.22087;

  D.22069 = type->type;
  if (D.22069 == 17) goto <D.22070>; else goto <D.22071>;
  <D.22070>:
  D.22072 = type->data.klass;
  D.22073 = BIT_FIELD_REF <*D.22072, 64, 256>;
  D.22074 = D.22073 & 576460752303423488;
  if (D.22074 != 0) goto <D.22075>; else goto <D.22076>;
  <D.22075>:
  D.22077 = BIT_FIELD_REF <*type, 64, 64>;
  D.22078 = D.22077 & 8589934592;
  if (D.22078 == 0) goto <D.22079>; else goto <D.22080>;
  <D.22079>:
  D.22072 = type->data.klass;
  D.22081 = mono_class_enum_basetype (D.22072);
  return D.22081;
  <D.22080>:
  <D.22076>:
  <D.22071>:
  D.22069 = type->type;
  if (D.22069 == 21) goto <D.22082>; else goto <D.22083>;
  <D.22082>:
  D.22084 = type->data.generic_class;
  D.22085 = D.22084->container_class;
  D.22086 = BIT_FIELD_REF <*D.22085, 64, 256>;
  D.22087 = D.22086 & 576460752303423488;
  if (D.22087 != 0) goto <D.22088>; else goto <D.22089>;
  <D.22088>:
  D.22077 = BIT_FIELD_REF <*type, 64, 64>;
  D.22078 = D.22077 & 8589934592;
  if (D.22078 == 0) goto <D.22090>; else goto <D.22091>;
  <D.22090>:
  D.22084 = type->data.generic_class;
  D.22085 = D.22084->container_class;
  D.22081 = mono_class_enum_basetype (D.22085);
  return D.22081;
  <D.22091>:
  <D.22089>:
  <D.22083>:
  D.22081 = type;
  return D.22081;
}


__attribute__((visibility ("hidden")))
mono_class_is_open_constructed_type (struct MonoType * t)
{
  unsigned char D.22093;
  int D.22094;
  gboolean D.22095;
  struct MonoClass * D.22096;
  struct MonoType * D.22097;
  struct MonoArrayType * D.22098;
  struct MonoClass * D.22099;
  struct MonoType * D.22100;
  struct MonoType * D.22101;
  struct MonoGenericClass * D.22102;
  struct MonoGenericInst * D.22103;
  <unnamed-unsigned:1> D.22104;
  struct MonoGenericContainer * D.22105;
  _Bool D.22106;

  D.22093 = t->type;
  D.22094 = (int) D.22093;
  switch (D.22094) <default: <D.19084>, case 15: <D.19080>, case 17: <D.19083>, case 18: <D.19082>, case 19: <D.19076>, case 20: <D.19079>, case 21: <D.19081>, case 29: <D.19078>, case 30: <D.19077>>
  <D.19076>:
  <D.19077>:
  D.22095 = 1;
  return D.22095;
  <D.19078>:
  D.22096 = t->data.klass;
  D.22097 = &D.22096->byval_arg;
  D.22095 = mono_class_is_open_constructed_type (D.22097);
  return D.22095;
  <D.19079>:
  D.22098 = t->data.array;
  D.22099 = D.22098->eklass;
  D.22100 = &D.22099->byval_arg;
  D.22095 = mono_class_is_open_constructed_type (D.22100);
  return D.22095;
  <D.19080>:
  D.22101 = t->data.type;
  D.22095 = mono_class_is_open_constructed_type (D.22101);
  return D.22095;
  <D.19081>:
  D.22102 = t->data.generic_class;
  D.22103 = D.22102->context.class_inst;
  D.22104 = D.22103->is_open;
  D.22095 = (gboolean) D.22104;
  return D.22095;
  <D.19082>:
  <D.19083>:
  D.22096 = t->data.klass;
  D.22105 = D.22096->generic_container;
  D.22106 = D.22105 != 0B;
  D.22095 = (gboolean) D.22106;
  return D.22095;
  <D.19084>:
  D.22095 = 0;
  return D.22095;
}


__attribute__((visibility ("hidden")))
mono_generic_class_get_context (struct MonoGenericClass * gclass)
{
  struct MonoGenericContext * D.22108;

  D.22108 = &gclass->context;
  return D.22108;
}


__attribute__((visibility ("hidden")))
mono_class_get_context (struct MonoClass * class)
{
  struct MonoGenericContext * D.22110;
  struct MonoGenericContext * iftmp.32;
  struct MonoGenericClass * D.22112;

  D.22112 = class->generic_class;
  if (D.22112 != 0B) goto <D.22113>; else goto <D.22114>;
  <D.22113>:
  D.22112 = class->generic_class;
  iftmp.32 = mono_generic_class_get_context (D.22112);
  goto <D.22115>;
  <D.22114>:
  iftmp.32 = 0B;
  <D.22115>:
  D.22110 = iftmp.32;
  return D.22110;
}


__attribute__((visibility ("hidden")))
mono_class_get_generic_container (struct MonoClass * klass)
{
  long unsigned int D.22117;
  long unsigned int D.22118;
  _Bool D.22119;
  long int D.22120;
  long int D.22121;
  struct MonoGenericContainer * D.22124;

  D.22117 = BIT_FIELD_REF <*klass, 64, 256>;
  D.22118 = D.22117 & 536870912;
  D.22119 = D.22118 == 0;
  D.22120 = (long int) D.22119;
  D.22121 = __builtin_expect (D.22120, 0);
  if (D.22121 != 0) goto <D.22122>; else goto <D.22123>;
  <D.22122>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "class.c", 752, "klass->is_generic");
  <D.22123>:
  D.22124 = klass->generic_container;
  return D.22124;
}


__attribute__((visibility ("hidden")))
mono_class_get_generic_class (struct MonoClass * klass)
{
  long unsigned int D.22126;
  long unsigned int D.22127;
  _Bool D.22128;
  long int D.22129;
  long int D.22130;
  struct MonoGenericClass * D.22133;

  D.22126 = BIT_FIELD_REF <*klass, 64, 256>;
  D.22127 = D.22126 & 268435456;
  D.22128 = D.22127 == 0;
  D.22129 = (long int) D.22128;
  D.22130 = __builtin_expect (D.22129, 0);
  if (D.22130 != 0) goto <D.22131>; else goto <D.22132>;
  <D.22131>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "class.c", 765, "klass->is_inflated");
  <D.22132>:
  D.22133 = klass->generic_class;
  return D.22133;
}


__attribute__((visibility ("hidden")))
mono_class_inflate_generic_type_with_mempool (struct MonoImage * image, struct MonoType * type, struct MonoGenericContext * context, struct MonoError * error)
{
  int D.22137;
  struct MonoType * D.22140;
  long unsigned int D.22145;
  long unsigned int D.22146;
  struct MonoType * inflated;

  inflated = 0B;
  mono_error_init (error);
  if (context != 0B) goto <D.22135>; else goto <D.22136>;
  <D.22135>:
  inflated = inflate_generic_type (image, type, context, error);
  <D.22136>:
  D.22137 = mono_error_ok (error);
  if (D.22137 == 0) goto <D.22138>; else goto <D.22139>;
  <D.22138>:
  D.22140 = 0B;
  return D.22140;
  <D.22139>:
  if (inflated == 0B) goto <D.22141>; else goto <D.22142>;
  <D.22141>:
  {
    struct MonoType * shared;

    shared = mono_metadata_get_shared_type (type);
    if (shared != 0B) goto <D.22143>; else goto <D.22144>;
    <D.22143>:
    D.22140 = shared;
    return D.22140;
    <D.22144>:
    D.22140 = mono_metadata_type_dup (image, type);
    return D.22140;
  }
  <D.22142>:
  D.22145 = mono_stats.inflated_type_count;
  D.22146 = D.22145 + 1;
  mono_stats.inflated_type_count = D.22146;
  D.22140 = inflated;
  return D.22140;
}


inflate_generic_type (struct MonoImage * image, struct MonoType * type, struct MonoGenericContext * context, struct MonoError * error)
{
  unsigned char D.22148;
  int D.22149;
  struct MonoGenericParam * D.22150;
  short unsigned int D.22151;
  struct MonoType *[0:] * D.22155;
  struct MonoType * D.22156;
  <unnamed-unsigned:22> D.22157;
  int D.22158;
  struct MonoGenericParamInfo * iftmp.33;
  struct MonoGenericContainer * D.22162;
  const char * iftmp.34;
  struct MonoType * D.22170;
  int D.22171;
  struct MonoGenericParamInfo * iftmp.35;
  const char * iftmp.36;
  unsigned char D.22182;
  int D.22183;
  <unnamed-unsigned:1> D.22184;
  short unsigned int D.22185;
  <unnamed-unsigned:22> D.22188;
  int D.22189;
  struct MonoGenericParamInfo * iftmp.37;
  const char * iftmp.38;
  struct MonoType * D.22200;
  int D.22201;
  struct MonoGenericParamInfo * iftmp.39;
  const char * iftmp.40;
  unsigned char D.22212;
  int D.22213;
  struct MonoType * D.22214;
  int D.22218;
  struct MonoClass * D.22219;
  struct MonoArrayType * D.22220;
  struct MonoType * D.22221;
  int D.22225;
  struct MonoArrayType * D.22226;
  struct MonoClass * D.22227;
  struct MonoGenericInst * D.22228;
  long unsigned int D.22229;
  long unsigned int D.22230;
  int D.22233;
  struct MonoClass * D.22238;
  <unnamed-unsigned:1> D.22239;
  int D.22240;
  struct MonoGenericClass * D.22241;
  struct MonoGenericInst * D.22246;
  int D.22247;
  struct MonoImage * D.22252;
  <unnamed-unsigned:1> D.22253;
  int D.22254;

  mono_error_init (error);
  D.22148 = type->type;
  D.22149 = (int) D.22148;
  switch (D.22149) <default: <D.19126>, case 17: <D.19120>, case 18: <D.19119>, case 19: <D.19101>, case 20: <D.19111>, case 21: <D.19115>, case 29: <D.19107>, case 30: <D.19095>>
  <D.19095>:
  {
    struct MonoType * nt;
    int num;
    struct MonoGenericInst * inst;

    D.22150 = type->data.generic_param;
    D.22151 = D.22150->num;
    num = (int) D.22151;
    inst = context->method_inst;
    if (inst == 0B) goto <D.22152>; else goto <D.22154>;
    <D.22154>:
    D.22155 = &inst->type_argv;
    if (D.22155 == 0B) goto <D.22152>; else goto <D.22153>;
    <D.22152>:
    D.22156 = 0B;
    return D.22156;
    <D.22153>:
    D.22157 = inst->type_argc;
    D.22158 = (int) D.22157;
    if (D.22158 <= num) goto <D.22159>; else goto <D.22160>;
    <D.22159>:
    {
      struct MonoGenericParamInfo * info;

      D.22150 = type->data.generic_param;
      D.22162 = D.22150->owner;
      if (D.22162 != 0B) goto <D.22163>; else goto <D.22164>;
      <D.22163>:
      D.22150 = type->data.generic_param;
      iftmp.33 = &MEM[(struct MonoGenericParamFull *)D.22150].info;
      goto <D.22165>;
      <D.22164>:
      iftmp.33 = 0B;
      <D.22165>:
      info = iftmp.33;
      if (info != 0B) goto <D.22167>; else goto <D.22168>;
      <D.22167>:
      iftmp.34 = info->name;
      goto <D.22169>;
      <D.22168>:
      iftmp.34 = "";
      <D.22169>:
      D.22157 = inst->type_argc;
      D.22158 = (int) D.22157;
      mono_error_set_bad_image (error, image, "MVAR %d (%s) cannot be expanded in this context with %d instantiations", num, iftmp.34, D.22158);
      D.22156 = 0B;
      return D.22156;
    }
    <D.22160>:
    D.22170 = inst->type_argv[num];
    D.22171 = is_valid_generic_argument (D.22170);
    if (D.22171 == 0) goto <D.22172>; else goto <D.22173>;
    <D.22172>:
    {
      struct MonoGenericParamInfo * info;

      D.22150 = type->data.generic_param;
      D.22162 = D.22150->owner;
      if (D.22162 != 0B) goto <D.22175>; else goto <D.22176>;
      <D.22175>:
      D.22150 = type->data.generic_param;
      iftmp.35 = &MEM[(struct MonoGenericParamFull *)D.22150].info;
      goto <D.22177>;
      <D.22176>:
      iftmp.35 = 0B;
      <D.22177>:
      info = iftmp.35;
      if (info != 0B) goto <D.22179>; else goto <D.22180>;
      <D.22179>:
      iftmp.36 = info->name;
      goto <D.22181>;
      <D.22180>:
      iftmp.36 = "";
      <D.22181>:
      D.22170 = inst->type_argv[num];
      D.22182 = D.22170->type;
      D.22183 = (int) D.22182;
      mono_error_set_bad_image (error, image, "MVAR %d (%s) cannot be expanded with type 0x%x", num, iftmp.36, D.22183);
      D.22156 = 0B;
      return D.22156;
    }
    <D.22173>:
    D.22170 = inst->type_argv[num];
    nt = mono_metadata_type_dup (image, D.22170);
    D.22184 = type->byref;
    nt->byref = D.22184;
    D.22185 = type->attrs;
    nt->attrs = D.22185;
    D.22156 = nt;
    return D.22156;
  }
  <D.19101>:
  {
    struct MonoType * nt;
    int num;
    struct MonoGenericInst * inst;

    D.22150 = type->data.generic_param;
    D.22151 = D.22150->num;
    num = (int) D.22151;
    inst = context->class_inst;
    if (inst == 0B) goto <D.22186>; else goto <D.22187>;
    <D.22186>:
    D.22156 = 0B;
    return D.22156;
    <D.22187>:
    D.22188 = inst->type_argc;
    D.22189 = (int) D.22188;
    if (D.22189 <= num) goto <D.22190>; else goto <D.22191>;
    <D.22190>:
    {
      struct MonoGenericParamInfo * info;

      D.22150 = type->data.generic_param;
      D.22162 = D.22150->owner;
      if (D.22162 != 0B) goto <D.22193>; else goto <D.22194>;
      <D.22193>:
      D.22150 = type->data.generic_param;
      iftmp.37 = &MEM[(struct MonoGenericParamFull *)D.22150].info;
      goto <D.22195>;
      <D.22194>:
      iftmp.37 = 0B;
      <D.22195>:
      info = iftmp.37;
      if (info != 0B) goto <D.22197>; else goto <D.22198>;
      <D.22197>:
      iftmp.38 = info->name;
      goto <D.22199>;
      <D.22198>:
      iftmp.38 = "";
      <D.22199>:
      D.22188 = inst->type_argc;
      D.22189 = (int) D.22188;
      mono_error_set_bad_image (error, image, "VAR %d (%s) cannot be expanded in this context with %d instantiations", num, iftmp.38, D.22189);
      D.22156 = 0B;
      return D.22156;
    }
    <D.22191>:
    D.22200 = inst->type_argv[num];
    D.22201 = is_valid_generic_argument (D.22200);
    if (D.22201 == 0) goto <D.22202>; else goto <D.22203>;
    <D.22202>:
    {
      struct MonoGenericParamInfo * info;

      D.22150 = type->data.generic_param;
      D.22162 = D.22150->owner;
      if (D.22162 != 0B) goto <D.22205>; else goto <D.22206>;
      <D.22205>:
      D.22150 = type->data.generic_param;
      iftmp.39 = &MEM[(struct MonoGenericParamFull *)D.22150].info;
      goto <D.22207>;
      <D.22206>:
      iftmp.39 = 0B;
      <D.22207>:
      info = iftmp.39;
      if (info != 0B) goto <D.22209>; else goto <D.22210>;
      <D.22209>:
      iftmp.40 = info->name;
      goto <D.22211>;
      <D.22210>:
      iftmp.40 = "";
      <D.22211>:
      D.22200 = inst->type_argv[num];
      D.22212 = D.22200->type;
      D.22213 = (int) D.22212;
      mono_error_set_bad_image (error, image, "VAR %d (%s) cannot be expanded with type 0x%x", num, iftmp.40, D.22213);
      D.22156 = 0B;
      return D.22156;
    }
    <D.22203>:
    D.22200 = inst->type_argv[num];
    nt = mono_metadata_type_dup (image, D.22200);
    D.22184 = type->byref;
    nt->byref = D.22184;
    D.22185 = type->attrs;
    nt->attrs = D.22185;
    D.22156 = nt;
    return D.22156;
  }
  <D.19107>:
  {
    struct MonoClass * eclass;
    struct MonoType * nt;
    struct MonoType * inflated;

    eclass = type->data.klass;
    D.22214 = &eclass->byval_arg;
    inflated = inflate_generic_type (0B, D.22214, context, error);
    if (inflated == 0B) goto <D.22215>; else goto <D.22217>;
    <D.22217>:
    D.22218 = mono_error_ok (error);
    if (D.22218 == 0) goto <D.22215>; else goto <D.22216>;
    <D.22215>:
    D.22156 = 0B;
    return D.22156;
    <D.22216>:
    nt = mono_metadata_type_dup (image, type);
    D.22219 = mono_class_from_mono_type (inflated);
    nt->data.klass = D.22219;
    mono_metadata_free_type (inflated);
    D.22156 = nt;
    return D.22156;
  }
  <D.19111>:
  {
    struct MonoClass * eclass;
    struct MonoType * nt;
    struct MonoType * inflated;

    D.22220 = type->data.array;
    eclass = D.22220->eklass;
    D.22221 = &eclass->byval_arg;
    inflated = inflate_generic_type (0B, D.22221, context, error);
    if (inflated == 0B) goto <D.22222>; else goto <D.22224>;
    <D.22224>:
    D.22225 = mono_error_ok (error);
    if (D.22225 == 0) goto <D.22222>; else goto <D.22223>;
    <D.22222>:
    D.22156 = 0B;
    return D.22156;
    <D.22223>:
    nt = mono_metadata_type_dup (image, type);
    D.22226 = nt->data.array;
    D.22227 = mono_class_from_mono_type (inflated);
    D.22226->eklass = D.22227;
    mono_metadata_free_type (inflated);
    D.22156 = nt;
    return D.22156;
  }
  <D.19115>:
  {
    struct MonoGenericClass * gclass;
    struct MonoGenericInst * inst;
    struct MonoType * nt;

    gclass = type->data.generic_class;
    D.22228 = gclass->context.class_inst;
    D.22229 = BIT_FIELD_REF <*D.22228, 64, 0>;
    D.22230 = D.22229 & 512;
    if (D.22230 == 0) goto <D.22231>; else goto <D.22232>;
    <D.22231>:
    D.22156 = 0B;
    return D.22156;
    <D.22232>:
    D.22228 = gclass->context.class_inst;
    inst = mono_metadata_inflate_generic_inst (D.22228, context, error);
    D.22233 = mono_error_ok (error);
    if (D.22233 == 0) goto <D.22234>; else goto <D.22235>;
    <D.22234>:
    D.22156 = 0B;
    return D.22156;
    <D.22235>:
    D.22228 = gclass->context.class_inst;
    if (D.22228 != inst) goto <D.22236>; else goto <D.22237>;
    <D.22236>:
    D.22238 = gclass->container_class;
    D.22239 = gclass->is_dynamic;
    D.22240 = (int) D.22239;
    gclass = mono_metadata_lookup_generic_class (D.22238, inst, D.22240);
    <D.22237>:
    D.22241 = type->data.generic_class;
    if (D.22241 == gclass) goto <D.22242>; else goto <D.22243>;
    <D.22242>:
    D.22156 = 0B;
    return D.22156;
    <D.22243>:
    nt = mono_metadata_type_dup (image, type);
    nt->data.generic_class = gclass;
    D.22156 = nt;
    return D.22156;
  }
  <D.19119>:
  <D.19120>:
  {
    struct MonoClass * klass;
    struct MonoGenericContainer * container;
    struct MonoGenericInst * inst;
    struct MonoGenericClass * gclass;
    struct MonoType * nt;

    klass = type->data.klass;
    container = klass->generic_container;
    gclass = 0B;
    if (container == 0B) goto <D.22244>; else goto <D.22245>;
    <D.22244>:
    D.22156 = 0B;
    return D.22156;
    <D.22245>:
    D.22246 = container->context.class_inst;
    inst = mono_metadata_inflate_generic_inst (D.22246, context, error);
    D.22247 = mono_error_ok (error);
    if (D.22247 == 0) goto <D.22248>; else goto <D.22249>;
    <D.22248>:
    D.22156 = 0B;
    return D.22156;
    <D.22249>:
    D.22246 = container->context.class_inst;
    if (D.22246 == inst) goto <D.22250>; else goto <D.22251>;
    <D.22250>:
    D.22156 = 0B;
    return D.22156;
    <D.22251>:
    D.22252 = klass->image;
    D.22253 = D.22252->dynamic;
    D.22254 = (int) D.22253;
    gclass = mono_metadata_lookup_generic_class (klass, inst, D.22254);
    nt = mono_metadata_type_dup (image, type);
    nt->type = 21;
    nt->data.generic_class = gclass;
    D.22156 = nt;
    return D.22156;
  }
  <D.19126>:
  D.22156 = 0B;
  return D.22156;
  D.22156 = 0B;
  return D.22156;
}


is_valid_generic_argument (struct MonoType * type)
{
  unsigned char D.22256;
  int D.22257;
  gboolean D.22258;

  D.22256 = type->type;
  D.22257 = (int) D.22256;
  switch (D.22257) <default: <D.22259>, case 1: <D.19088>>
  <D.19088>:
  D.22258 = 0;
  return D.22258;
  <D.22259>:
  D.22258 = 1;
  return D.22258;
}


mono_class_inflate_generic_type (struct MonoType * type, struct MonoGenericContext * context)
{
  int D.22261;
  struct MonoType * D.22264;
  struct MonoError error;
  struct MonoType * result;

  try
    {
      result = mono_class_inflate_generic_type_checked (type, context, &error);
      D.22261 = mono_error_ok (&error);
      if (D.22261 == 0) goto <D.22262>; else goto <D.22263>;
      <D.22262>:
      mono_error_cleanup (&error);
      D.22264 = 0B;
      return D.22264;
      <D.22263>:
      D.22264 = result;
      return D.22264;
    }
  finally
    {
      error = {CLOBBER};
    }
}


__attribute__((visibility ("hidden")))
mono_class_inflate_generic_type_checked (struct MonoType * type, struct MonoGenericContext * context, struct MonoError * error)
{
  struct MonoType * D.22267;

  D.22267 = mono_class_inflate_generic_type_with_mempool (0B, type, context, error);
  return D.22267;
}


__attribute__((visibility ("hidden")))
mono_class_inflate_generic_class (struct MonoClass * gklass, struct MonoGenericContext * context)
{
  int D.22269;
  _Bool D.22270;
  long int D.22271;
  long int D.22272;
  struct MonoClass * D.22275;
  struct MonoError error;
  struct MonoClass * res;

  try
    {
      res = mono_class_inflate_generic_class_checked (gklass, context, &error);
      D.22269 = mono_error_ok (&error);
      D.22270 = D.22269 == 0;
      D.22271 = (long int) D.22270;
      D.22272 = __builtin_expect (D.22271, 0);
      if (D.22272 != 0) goto <D.22273>; else goto <D.22274>;
      <D.22273>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "class.c", 905, "mono_error_ok (&error)");
      <D.22274>:
      D.22275 = res;
      return D.22275;
    }
  finally
    {
      error = {CLOBBER};
    }
}


mono_class_inflate_generic_method (struct MonoMethod * method, struct MonoGenericContext * context)
{
  struct MonoMethod * D.22278;

  D.22278 = mono_class_inflate_generic_method_full (method, 0B, context);
  return D.22278;
}


__attribute__((visibility ("hidden")))
mono_class_inflate_generic_method_full (struct MonoMethod * method, struct MonoClass * klass_hint, struct MonoGenericContext * context)
{
  int D.22280;
  const char * D.22283;
  struct MonoMethod * D.22284;
  struct MonoError error;
  struct MonoMethod * res;

  try
    {
      res = mono_class_inflate_generic_method_full_checked (method, klass_hint, context, &error);
      D.22280 = mono_error_ok (&error);
      if (D.22280 == 0) goto <D.22281>; else goto <D.22282>;
      <D.22281>:
      D.22283 = mono_error_get_message (&error);
      monoeg_g_log (0B, 4, "Could not inflate generic method due to %s", D.22283);
      <D.19198>:
      goto <D.19198>;
      <D.22282>:
      D.22284 = res;
      return D.22284;
    }
  finally
    {
      error = {CLOBBER};
    }
}


__attribute__((visibility ("hidden")))
mono_class_inflate_generic_method_full_checked (struct MonoMethod * method, struct MonoClass * klass_hint, struct MonoGenericContext * context, struct MonoError * error)
{
  int D.22287;
  struct MonoMethod * D.22290;
  int D.22291;
  long unsigned int D.22294;
  long unsigned int D.22295;
  long unsigned int D.22299;
  struct MonoGenericInst * D.22301;
  struct MonoClass * D.22302;
  struct MonoGenericContainer * D.22303;
  struct MonoGenericInst * D.22305;
  int iftmp.41;
  struct MonoImage * D.22310;
  long unsigned int D.22311;
  long unsigned int D.22312;
  long unsigned int D.22314;
  long unsigned int D.22315;
  struct MonoGenericContainer * D.22317;
  struct MonoGenericInst * D.22318;
  unsigned char D.22320;
  <unnamed-unsigned:1> D.22321;
  struct MonoGenericContainer * D.22326;
  struct MonoGenericInst * D.22327;
  struct MonoMethod * D.22330;
  struct MonoClass * D.22331;
  struct MonoGenericClass * D.22332;
  _Bool D.22333;
  long int D.22334;
  long int D.22335;
  struct MonoGenericContainer * D.22338;
  struct MonoGenericInst * D.22341;
  struct MonoGenericInst * D.22345;
  long unsigned int D.22348;
  long unsigned int D.22349;
  unsigned int inflated_methods_size.42;
  unsigned int D.22351;
  const char * D.22354;
  long unsigned int D.22355;
  long unsigned int D.22356;
  struct MonoMethodPInvoke * D.22359;
  struct MonoMethod * D.22361;
  struct MonoGenericClass * D.22369;
  struct MonoClass * D.22371;
  struct MonoGenericInst * D.22373;
  struct MonoClass * D.22376;
  struct MonoType * D.22379;
  int D.22380;
  struct MonoClass * iftmp.43;
  struct MonoMethod * result;
  struct MonoMethodInflated * iresult;
  struct MonoMethodInflated * cached;
  struct MonoMethodSignature * sig;
  struct MonoGenericContext tmp_context;
  gboolean is_mb_open;
  void fail = <<< error >>>;

  try
    {
      is_mb_open = 0;
      mono_error_init (error);
      goto <D.19214>;
      <D.19213>:
      {
        struct MonoGenericContext * method_context;
        struct MonoMethodInflated * imethod;

        method_context = mono_method_get_context (method);
        imethod = method;
        tmp_context = inflate_generic_context (method_context, context, error);
        D.22287 = mono_error_ok (error);
        if (D.22287 == 0) goto <D.22288>; else goto <D.22289>;
        <D.22288>:
        D.22290 = 0B;
        return D.22290;
        <D.22289>:
        context = &tmp_context;
        D.22291 = mono_metadata_generic_context_equal (method_context, context);
        if (D.22291 != 0) goto <D.22292>; else goto <D.22293>;
        <D.22292>:
        D.22290 = method;
        return D.22290;
        <D.22293>:
        method = imethod->declaring;
      }
      <D.19214>:
      D.22294 = BIT_FIELD_REF <*method, 64, 256>;
      D.22295 = D.22294 & 2251799813685248;
      if (D.22295 != 0) goto <D.19213>; else goto <D.19215>;
      <D.19215>:
      D.22294 = BIT_FIELD_REF <*method, 64, 256>;
      D.22299 = D.22294 & 4503599627370496;
      if (D.22299 == 0) goto <D.22298>; else goto <D.22300>;
      <D.22300>:
      D.22301 = context->method_inst;
      if (D.22301 == 0B) goto <D.22298>; else goto <D.22297>;
      <D.22298>:
      D.22302 = method->klass;
      D.22303 = D.22302->generic_container;
      if (D.22303 == 0B) goto <D.22296>; else goto <D.22304>;
      <D.22304>:
      D.22305 = context->class_inst;
      if (D.22305 == 0B) goto <D.22296>; else goto <D.22297>;
      <D.22296>:
      D.22290 = method;
      return D.22290;
      <D.22297>:
      D.22294 = BIT_FIELD_REF <*method, 64, 256>;
      D.22299 = D.22294 & 4503599627370496;
      if (D.22299 != 0) goto <D.22309>; else goto <D.22307>;
      <D.22309>:
      D.22302 = method->klass;
      D.22310 = D.22302->image;
      D.22311 = BIT_FIELD_REF <*D.22310, 64, 192>;
      D.22312 = D.22311 & 268435456;
      if (D.22312 != 0) goto <D.22313>; else goto <D.22307>;
      <D.22313>:
      D.22302 = method->klass;
      D.22314 = BIT_FIELD_REF <*D.22302, 64, 256>;
      D.22315 = D.22314 & 72057594037927936;
      if (D.22315 == 0) goto <D.22316>; else goto <D.22307>;
      <D.22316>:
      D.22301 = context->method_inst;
      D.22317 = mono_method_get_generic_container (method);
      D.22318 = D.22317->context.method_inst;
      if (D.22301 == D.22318) goto <D.22319>; else goto <D.22307>;
      <D.22319>:
      iftmp.41 = 1;
      goto <D.22308>;
      <D.22307>:
      iftmp.41 = 0;
      <D.22308>:
      is_mb_open = iftmp.41;
      iresult = monoeg_malloc0 (88);
      iresult->context = *context;
      iresult->declaring = method;
      D.22320 = (unsigned char) is_mb_open;
      D.22321 = (<unnamed-unsigned:1>) D.22320;
      iresult->method.method.is_mb_open = D.22321;
      D.22301 = context->method_inst;
      if (D.22301 == 0B) goto <D.22322>; else goto <D.22323>;
      <D.22322>:
      D.22294 = BIT_FIELD_REF <*method, 64, 256>;
      D.22299 = D.22294 & 4503599627370496;
      if (D.22299 != 0) goto <D.22324>; else goto <D.22325>;
      <D.22324>:
      D.22326 = mono_method_get_generic_container (method);
      D.22327 = D.22326->context.method_inst;
      iresult->context.method_inst = D.22327;
      <D.22325>:
      <D.22323>:
      D.22305 = context->class_inst;
      if (D.22305 == 0B) goto <D.22328>; else goto <D.22329>;
      <D.22328>:
      D.22330 = iresult->declaring;
      D.22331 = D.22330->klass;
      D.22332 = D.22331->generic_class;
      D.22333 = D.22332 != 0B;
      D.22334 = (long int) D.22333;
      D.22335 = __builtin_expect (D.22334, 0);
      if (D.22335 != 0) goto <D.22336>; else goto <D.22337>;
      <D.22336>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "class.c", 1059, "!iresult->declaring->klass->generic_class");
      <D.22337>:
      D.22330 = iresult->declaring;
      D.22331 = D.22330->klass;
      D.22338 = D.22331->generic_container;
      if (D.22338 != 0B) goto <D.22339>; else goto <D.22340>;
      <D.22339>:
      D.22330 = iresult->declaring;
      D.22331 = D.22330->klass;
      D.22338 = D.22331->generic_container;
      D.22341 = D.22338->context.class_inst;
      iresult->context.class_inst = D.22341;
      goto <D.22342>;
      <D.22340>:
      D.22330 = iresult->declaring;
      D.22331 = D.22330->klass;
      D.22332 = D.22331->generic_class;
      if (D.22332 != 0B) goto <D.22343>; else goto <D.22344>;
      <D.22343>:
      D.22330 = iresult->declaring;
      D.22331 = D.22330->klass;
      D.22332 = D.22331->generic_class;
      D.22345 = D.22332->context.class_inst;
      iresult->context.class_inst = D.22345;
      <D.22344>:
      <D.22342>:
      <D.22329>:
      mono_loader_lock ();
      cached = mono_method_inflated_lookup (iresult, 0);
      if (cached != 0B) goto <D.22346>; else goto <D.22347>;
      <D.22346>:
      mono_loader_unlock ();
      monoeg_g_free (iresult);
      D.22290 = cached;
      return D.22290;
      <D.22347>:
      D.22348 = mono_stats.inflated_method_count;
      D.22349 = D.22348 + 1;
      mono_stats.inflated_method_count = D.22349;
      inflated_methods_size.42 = inflated_methods_size;
      D.22351 = inflated_methods_size.42 + 88;
      inflated_methods_size = D.22351;
      sig = mono_method_signature (method);
      if (sig == 0B) goto <D.22352>; else goto <D.22353>;
      <D.22352>:
      {
        char * name;

        D.22302 = method->klass;
        name = mono_type_get_full_name (D.22302);
        D.22302 = method->klass;
        D.22310 = D.22302->image;
        D.22354 = method->name;
        mono_error_set_bad_image (error, D.22310, "Could not resolve signature of method %s:%s", name, D.22354);
        monoeg_g_free (name);
        goto fail;
      }
      <D.22353>:
      D.22355 = BIT_FIELD_REF <*sig, 64, 64>;
      D.22356 = D.22355 & 128;
      if (D.22356 != 0) goto <D.22357>; else goto <D.22358>;
      <D.22357>:
      D.22359 = &iresult->method.pinvoke;
      memcpy (D.22359, method, 56);
      goto <D.22360>;
      <D.22358>:
      D.22361 = &iresult->method.method;
      memcpy (D.22361, method, 40);
      <D.22360>:
      result = iresult;
      result->is_inflated = 1;
      result->is_generic = 0;
      result->sre_method = 0;
      result->signature = 0B;
      D.22320 = (unsigned char) is_mb_open;
      D.22321 = (<unnamed-unsigned:1>) D.22320;
      result->is_mb_open = D.22321;
      D.22301 = context->method_inst;
      if (D.22301 == 0B) goto <D.22362>; else goto <D.22363>;
      <D.22362>:
      {
        struct MonoGenericContainer * generic_container;

        generic_container = mono_method_get_generic_container (method);
        if (generic_container != 0B) goto <D.22364>; else goto <D.22365>;
        <D.22364>:
        result->is_generic = 1;
        mono_method_set_generic_container (result, generic_container);
        <D.22365>:
      }
      <D.22363>:
      if (klass_hint == 0B) goto <D.22366>; else goto <D.22368>;
      <D.22368>:
      D.22369 = klass_hint->generic_class;
      if (D.22369 == 0B) goto <D.22366>; else goto <D.22370>;
      <D.22370>:
      D.22369 = klass_hint->generic_class;
      D.22371 = D.22369->container_class;
      D.22302 = method->klass;
      if (D.22371 != D.22302) goto <D.22366>; else goto <D.22372>;
      <D.22372>:
      D.22369 = klass_hint->generic_class;
      D.22373 = D.22369->context.class_inst;
      D.22305 = context->class_inst;
      if (D.22373 != D.22305) goto <D.22366>; else goto <D.22367>;
      <D.22366>:
      klass_hint = 0B;
      <D.22367>:
      D.22302 = method->klass;
      D.22303 = D.22302->generic_container;
      if (D.22303 != 0B) goto <D.22374>; else goto <D.22375>;
      <D.22374>:
      result->klass = klass_hint;
      <D.22375>:
      D.22376 = result->klass;
      if (D.22376 == 0B) goto <D.22377>; else goto <D.22378>;
      <D.22377>:
      {
        struct MonoType * inflated;

        D.22302 = method->klass;
        D.22379 = &D.22302->byval_arg;
        inflated = inflate_generic_type (0B, D.22379, context, error);
        D.22380 = mono_error_ok (error);
        if (D.22380 == 0) goto fail; else goto <D.22381>;
        <D.22381>:
        if (inflated != 0B) goto <D.22383>; else goto <D.22384>;
        <D.22383>:
        iftmp.43 = mono_class_from_mono_type (inflated);
        goto <D.22385>;
        <D.22384>:
        iftmp.43 = method->klass;
        <D.22385>:
        result->klass = iftmp.43;
        if (inflated != 0B) goto <D.22386>; else goto <D.22387>;
        <D.22386>:
        mono_metadata_free_type (inflated);
        <D.22387>:
      }
      <D.22378>:
      mono_method_inflated_lookup (iresult, 1);
      mono_loader_unlock ();
      D.22290 = result;
      return D.22290;
      fail:
      mono_loader_unlock ();
      monoeg_g_free (iresult);
      D.22290 = 0B;
      return D.22290;
    }
  finally
    {
      tmp_context = {CLOBBER};
    }
}


inflate_generic_context (struct MonoGenericContext * context, struct MonoGenericContext * inflate_with, struct MonoError * error)
{
  struct MonoGenericInst * D.22391;
  int D.22394;
  struct MonoGenericInst * D.22396;
  int D.22399;
  struct MonoGenericInst * class_inst;
  struct MonoGenericInst * method_inst;
  struct MonoGenericContext res;
  void fail = <<< error >>>;

  try
    {
      class_inst = 0B;
      method_inst = 0B;
      res.class_inst = 0B;
      res.method_inst = 0B;
      mono_error_init (error);
      D.22391 = context->class_inst;
      if (D.22391 != 0B) goto <D.22392>; else goto <D.22393>;
      <D.22392>:
      D.22391 = context->class_inst;
      class_inst = mono_metadata_inflate_generic_inst (D.22391, inflate_with, error);
      D.22394 = mono_error_ok (error);
      if (D.22394 == 0) goto fail; else goto <D.22395>;
      <D.22395>:
      <D.22393>:
      D.22396 = context->method_inst;
      if (D.22396 != 0B) goto <D.22397>; else goto <D.22398>;
      <D.22397>:
      D.22396 = context->method_inst;
      method_inst = mono_metadata_inflate_generic_inst (D.22396, inflate_with, error);
      D.22399 = mono_error_ok (error);
      if (D.22399 == 0) goto fail; else goto <D.22400>;
      <D.22400>:
      <D.22398>:
      res.class_inst = class_inst;
      res.method_inst = method_inst;
      fail:
      <retval> = res;
      return <retval>;
    }
  finally
    {
      res = {CLOBBER};
    }
}


mono_get_inflated_method (struct MonoMethod * method)
{
  struct MonoMethod * D.22403;

  D.22403 = method;
  return D.22403;
}


__attribute__((visibility ("hidden")))
mono_method_get_context_general (struct MonoMethod * method, gboolean uninflated)
{
  long unsigned int D.22405;
  long unsigned int D.22406;
  struct MonoGenericContext * D.22409;
  long unsigned int D.22412;
  struct MonoGenericContainer * D.22415;
  struct MonoClass * D.22416;
  struct MonoGenericContainer * D.22417;

  D.22405 = BIT_FIELD_REF <*method, 64, 256>;
  D.22406 = D.22405 & 2251799813685248;
  if (D.22406 != 0) goto <D.22407>; else goto <D.22408>;
  <D.22407>:
  {
    struct MonoMethodInflated * imethod;

    imethod = method;
    D.22409 = &imethod->context;
    return D.22409;
  }
  <D.22408>:
  if (uninflated == 0) goto <D.22410>; else goto <D.22411>;
  <D.22410>:
  D.22409 = 0B;
  return D.22409;
  <D.22411>:
  D.22405 = BIT_FIELD_REF <*method, 64, 256>;
  D.22412 = D.22405 & 4503599627370496;
  if (D.22412 != 0) goto <D.22413>; else goto <D.22414>;
  <D.22413>:
  D.22415 = mono_method_get_generic_container (method);
  D.22409 = &D.22415->context;
  return D.22409;
  <D.22414>:
  D.22416 = method->klass;
  D.22417 = D.22416->generic_container;
  if (D.22417 != 0B) goto <D.22418>; else goto <D.22419>;
  <D.22418>:
  D.22416 = method->klass;
  D.22417 = D.22416->generic_container;
  D.22409 = &D.22417->context;
  return D.22409;
  <D.22419>:
  D.22409 = 0B;
  return D.22409;
}


__attribute__((visibility ("hidden")))
mono_method_get_context (struct MonoMethod * method)
{
  struct MonoGenericContext * D.22421;

  D.22421 = mono_method_get_context_general (method, 0);
  return D.22421;
}


mono_method_get_generic_container (struct MonoMethod * method)
{
  long unsigned int D.22423;
  long unsigned int D.22424;
  struct MonoGenericContainer * D.22427;
  struct MonoClass * D.22428;
  struct MonoImage * D.22429;
  _Bool D.22430;
  long int D.22431;
  long int D.22432;
  struct MonoGenericContainer * container;

  D.22423 = BIT_FIELD_REF <*method, 64, 256>;
  D.22424 = D.22423 & 4503599627370496;
  if (D.22424 == 0) goto <D.22425>; else goto <D.22426>;
  <D.22425>:
  D.22427 = 0B;
  return D.22427;
  <D.22426>:
  D.22428 = method->klass;
  D.22429 = D.22428->image;
  container = mono_image_property_lookup (D.22429, method, 0);
  D.22430 = container == 0B;
  D.22431 = (long int) D.22430;
  D.22432 = __builtin_expect (D.22431, 0);
  if (D.22432 != 0) goto <D.22433>; else goto <D.22434>;
  <D.22433>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "class.c", 1216, "container");
  <D.22434>:
  D.22427 = container;
  return D.22427;
}


__attribute__((visibility ("hidden")))
mono_method_set_generic_container (struct MonoMethod * method, struct MonoGenericContainer * container)
{
  long unsigned int D.22436;
  long unsigned int D.22437;
  _Bool D.22438;
  long int D.22439;
  long int D.22440;
  struct MonoClass * D.22443;
  struct MonoImage * D.22444;

  D.22436 = BIT_FIELD_REF <*method, 64, 256>;
  D.22437 = D.22436 & 4503599627370496;
  D.22438 = D.22437 == 0;
  D.22439 = (long int) D.22438;
  D.22440 = __builtin_expect (D.22439, 0);
  if (D.22440 != 0) goto <D.22441>; else goto <D.22442>;
  <D.22441>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "class.c", 1230, "method->is_generic");
  <D.22442>:
  D.22443 = method->klass;
  D.22444 = D.22443->image;
  mono_image_property_insert (D.22444, method, 0, container);
}


__attribute__((visibility ("hidden")))
mono_class_setup_fields_locking (struct MonoClass * class)
{
  long unsigned int D.22445;
  long unsigned int D.22446;

  D.22445 = BIT_FIELD_REF <*class, 64, 256>;
  D.22446 = D.22445 & 67108864;
  if (D.22446 != 0) goto <D.22447>; else goto <D.22448>;
  <D.22447>:
  return;
  <D.22448>:
  mono_loader_lock ();
  mono_class_setup_fields (class);
  mono_loader_unlock ();
}


mono_class_setup_fields (struct MonoClass * class)
{
  unsigned int D.22450;
  struct MonoClass * iftmp.44;
  struct MonoGenericClass * D.22452;
  long unsigned int D.22456;
  long unsigned int D.22457;
  struct MonoClass * D.22462;
  struct MonoImage * D.22463;
  long unsigned int D.22464;
  long unsigned int D.22465;
  long unsigned int D.22468;
  long unsigned int D.22469;
  unsigned int D.22472;
  unsigned char D.22475;
  unsigned char D.22478;
  struct MonoClass * D.22481;
  long unsigned int D.22484;
  long unsigned int D.22485;
  unsigned char D.22488;
  int D.22491;
  int D.22492;
  int D.22493;
  unsigned char D.22494;
  <unnamed-unsigned:1> D.22495;
  <unnamed-unsigned:1> D.22496;
  <unnamed-unsigned:1> D.22497;
  <unnamed-unsigned:1> D.22498;
  struct MonoImage * D.22500;
  unsigned int D.22501;
  unsigned int D.22502;
  unsigned int packing_size.45;
  unsigned int D.22506;
  const char * D.22509;
  unsigned char D.22510;
  <unnamed-unsigned:4> D.22511;
  unsigned int D.22512;
  unsigned int real_size.46;
  unsigned int real_size.47;
  unsigned int D.22521;
  int D.22522;
  unsigned char D.22523;
  <unnamed-unsigned:1> D.22524;
  struct MonoGenericContainer * D.22527;
  _Bool D.22533;
  long int D.22534;
  long int D.22535;
  unsigned int D.22538;
  unsigned int i.48;
  unsigned int D.22540;
  struct MonoClassField * D.22541;
  long unsigned int D.22542;
  long unsigned int D.22543;
  struct MonoType * D.22544;
  int D.22547;
  char * D.22552;
  const char * D.22553;
  _Bool D.22554;
  long int D.22555;
  long int D.22556;
  short unsigned int D.22559;
  int D.22560;
  int D.22561;
  const char * D.22564;
  int D.22565;
  struct MonoClassField * D.22570;
  int D.22571;
  unsigned int idx.49;
  unsigned int offset.50;
  int offset.51;
  int D.22578;
  int D.22581;
  gchar * D.22584;
  gchar * D.22587;
  long unsigned int D.22595;
  long unsigned int D.22596;
  int D.22598;
  unsigned char D.22601;
  long unsigned int D.22607;
  long unsigned int D.22608;
  long unsigned int D.22609;
  struct MonoClass * D.22614;
  struct MonoClass * D.22615;
  <unnamed-unsigned:1> D.22616;
  int D.22617;
  struct MonoClass * D.22620;
  struct MonoType * D.22625;
  unsigned char D.22632;
  long unsigned int D.22635;
  unsigned int D.22638;
  unsigned int D.22639;
  struct MonoError error;
  struct MonoImage * m;
  int top;
  guint32 layout;
  int i;
  int blittable;
  guint32 real_size;
  guint32 packing_size;
  gboolean explicit_size;
  struct MonoClassField * field;
  struct MonoGenericContainer * container;
  struct MonoClass * gtd;

  try
    {
      m = class->image;
      D.22450 = class->flags;
      layout = D.22450 & 24;
      blittable = 1;
      real_size = 0;
      packing_size = 0;
      container = 0B;
      D.22452 = class->generic_class;
      if (D.22452 != 0B) goto <D.22453>; else goto <D.22454>;
      <D.22453>:
      iftmp.44 = mono_class_get_generic_type_definition (class);
      goto <D.22455>;
      <D.22454>:
      iftmp.44 = 0B;
      <D.22455>:
      gtd = iftmp.44;
      D.22456 = BIT_FIELD_REF <*class, 64, 256>;
      D.22457 = D.22456 & 33554432;
      if (D.22457 != 0) goto <D.22458>; else goto <D.22459>;
      <D.22458>:
      return;
      <D.22459>:
      D.22452 = class->generic_class;
      if (D.22452 != 0B) goto <D.22460>; else goto <D.22461>;
      <D.22460>:
      D.22452 = class->generic_class;
      D.22462 = D.22452->container_class;
      D.22463 = D.22462->image;
      D.22464 = BIT_FIELD_REF <*D.22463, 64, 192>;
      D.22465 = D.22464 & 268435456;
      if (D.22465 != 0) goto <D.22466>; else goto <D.22467>;
      <D.22466>:
      D.22452 = class->generic_class;
      D.22462 = D.22452->container_class;
      D.22468 = BIT_FIELD_REF <*D.22462, 64, 256>;
      D.22469 = D.22468 & 72057594037927936;
      if (D.22469 == 0) goto <D.22470>; else goto <D.22471>;
      <D.22470>:
      return;
      <D.22471>:
      <D.22467>:
      <D.22461>:
      mono_class_setup_basic_field_info (class);
      D.22472 = class->field.count;
      top = (int) D.22472;
      if (gtd != 0B) goto <D.22473>; else goto <D.22474>;
      <D.22473>:
      mono_class_setup_fields (gtd);
      D.22475 = gtd->exception_type;
      if (D.22475 != 0) goto <D.22476>; else goto <D.22477>;
      <D.22476>:
      mono_class_set_failure (class, 7, 0B);
      return;
      <D.22477>:
      <D.22474>:
      class->instance_size = 0;
      D.22478 = class->rank;
      if (D.22478 == 0) goto <D.22479>; else goto <D.22480>;
      <D.22479>:
      class->sizes.class_size = 0;
      <D.22480>:
      D.22481 = class->parent;
      if (D.22481 != 0B) goto <D.22482>; else goto <D.22483>;
      <D.22482>:
      D.22481 = class->parent;
      mono_class_init (D.22481);
      D.22481 = class->parent;
      D.22484 = BIT_FIELD_REF <*D.22481, 64, 256>;
      D.22485 = D.22484 & 2305843009213693952;
      if (D.22485 == 0) goto <D.22486>; else goto <D.22487>;
      <D.22486>:
      D.22481 = class->parent;
      mono_class_setup_fields (D.22481);
      D.22481 = class->parent;
      D.22488 = D.22481->exception_type;
      if (D.22488 != 0) goto <D.22489>; else goto <D.22490>;
      <D.22489>:
      mono_class_set_failure (class, 7, 0B);
      return;
      <D.22490>:
      <D.22487>:
      D.22491 = class->instance_size;
      D.22481 = class->parent;
      D.22492 = D.22481->instance_size;
      D.22493 = D.22491 + D.22492;
      class->instance_size = D.22493;
      D.22481 = class->parent;
      D.22494 = D.22481->min_align;
      class->min_align = D.22494;
      D.22495 = class->has_references;
      D.22481 = class->parent;
      D.22496 = D.22481->has_references;
      D.22497 = D.22495 | D.22496;
      class->has_references = D.22497;
      D.22481 = class->parent;
      D.22498 = D.22481->blittable;
      blittable = (int) D.22498;
      goto <D.22499>;
      <D.22483>:
      class->instance_size = 16;
      class->min_align = 1;
      <D.22499>:
      D.22500 = class->image;
      D.22501 = class->type_token;
      D.22502 = mono_metadata_packing_from_typedef (D.22500, D.22501, &packing_size, &real_size);
      explicit_size = (gboolean) D.22502;
      if (explicit_size != 0) goto <D.22503>; else goto <D.22504>;
      <D.22503>:
      packing_size.45 = packing_size;
      D.22506 = packing_size.45 & 4294967280;
      if (D.22506 != 0) goto <D.22507>; else goto <D.22508>;
      <D.22507>:
      {
        char * err_msg;

        D.22509 = class->name;
        packing_size.45 = packing_size;
        err_msg = monoeg_g_strdup_printf ("Could not load struct \'%s\' with packing size %d >= 16", D.22509, packing_size.45);
        mono_class_set_failure (class, 7, err_msg);
        return;
      }
      <D.22508>:
      packing_size.45 = packing_size;
      D.22510 = (unsigned char) packing_size.45;
      D.22511 = (<unnamed-unsigned:4>) D.22510;
      class->packing_size = D.22511;
      D.22491 = class->instance_size;
      D.22512 = (unsigned int) D.22491;
      real_size.46 = real_size;
      real_size.47 = D.22512 + real_size.46;
      real_size = real_size.47;
      <D.22504>:
      if (top == 0) goto <D.22515>; else goto <D.22516>;
      <D.22515>:
      if (explicit_size != 0) goto <D.22517>; else goto <D.22518>;
      <D.22517>:
      real_size.46 = real_size;
      if (real_size.46 != 0) goto <D.22519>; else goto <D.22520>;
      <D.22519>:
      D.22491 = class->instance_size;
      D.22512 = (unsigned int) D.22491;
      real_size.46 = real_size;
      D.22521 = MAX_EXPR <D.22512, real_size.46>;
      D.22522 = (int) D.22521;
      class->instance_size = D.22522;
      <D.22520>:
      <D.22518>:
      D.22523 = (unsigned char) blittable;
      D.22524 = (<unnamed-unsigned:1>) D.22523;
      class->blittable = D.22524;
      mono_memory_barrier ();
      class->size_inited = 1;
      class->fields_inited = 1;
      class->setup_fields_called = 1;
      return;
      <D.22516>:
      if (layout == 0) goto <D.22525>; else goto <D.22526>;
      <D.22525>:
      blittable = 0;
      <D.22526>:
      class->setup_fields_called = 1;
      D.22527 = class->generic_container;
      if (D.22527 != 0B) goto <D.22528>; else goto <D.22529>;
      <D.22528>:
      container = class->generic_container;
      goto <D.22530>;
      <D.22529>:
      if (gtd != 0B) goto <D.22531>; else goto <D.22532>;
      <D.22531>:
      container = gtd->generic_container;
      D.22533 = container == 0B;
      D.22534 = (long int) D.22533;
      D.22535 = __builtin_expect (D.22534, 0);
      if (D.22535 != 0) goto <D.22536>; else goto <D.22537>;
      <D.22536>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "class.c", 1567, "container");
      <D.22537>:
      <D.22532>:
      <D.22530>:
      i = 0;
      goto <D.19311>;
      <D.19310>:
      {
        int idx;

        D.22538 = class->field.first;
        i.48 = (unsigned int) i;
        D.22540 = D.22538 + i.48;
        idx = (int) D.22540;
        D.22541 = class->fields;
        D.22542 = (long unsigned int) i;
        D.22543 = D.22542 * 32;
        field = D.22541 + D.22543;
        field->parent = class;
        D.22544 = field->type;
        if (D.22544 == 0B) goto <D.22545>; else goto <D.22546>;
        <D.22545>:
        mono_field_resolve_type (field, &error);
        D.22547 = mono_error_ok (&error);
        if (D.22547 == 0) goto <D.22548>; else goto <D.22549>;
        <D.22548>:
        mono_error_cleanup (&error);
        return;
        <D.22549>:
        D.22544 = field->type;
        if (D.22544 == 0B) goto <D.22550>; else goto <D.22551>;
        <D.22550>:
        D.22552 = mono_type_get_full_name (class);
        D.22553 = field->name;
        monoeg_g_log (0B, 4, "could not resolve %s:%s\n", D.22552, D.22553);
        <D.19302>:
        goto <D.19302>;
        <D.22551>:
        D.22544 = field->type;
        D.22554 = D.22544 == 0B;
        D.22555 = (long int) D.22554;
        D.22556 = __builtin_expect (D.22555, 0);
        if (D.22556 != 0) goto <D.22557>; else goto <D.22558>;
        <D.22557>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "class.c", 1588, "field->type");
        <D.22558>:
        <D.22546>:
        D.22544 = field->type;
        D.22559 = D.22544->attrs;
        D.22560 = (int) D.22559;
        D.22561 = D.22560 & 1536;
        if (D.22561 != 0) goto <D.22562>; else goto <D.22563>;
        <D.22562>:
        D.22564 = mono_field_get_name (field);
        D.22565 = strcmp (D.22564, "_Deleted");
        if (D.22565 == 0) goto <D.22566>; else goto <D.22567>;
        <D.22566>:
        // predicted unlikely by continue predictor.
        goto <D.19303>;
        <D.22567>:
        <D.22563>:
        if (gtd != 0B) goto <D.22568>; else goto <D.22569>;
        <D.22568>:
        {
          struct MonoClassField * gfield;

          D.22570 = gtd->fields;
          D.22542 = (long unsigned int) i;
          D.22543 = D.22542 * 32;
          gfield = D.22570 + D.22543;
          D.22571 = gfield->offset;
          field->offset = D.22571;
        }
        goto <D.22572>;
        <D.22569>:
        if (layout == 16) goto <D.22573>; else goto <D.22574>;
        <D.22573>:
        {
          guint32 offset;

          try
            {
              idx.49 = (unsigned int) idx;
              mono_metadata_field_info (m, idx.49, &offset, 0B, 0B);
              offset.50 = offset;
              offset.51 = (int) offset.50;
              field->offset = offset.51;
              D.22578 = field->offset;
              if (D.22578 == -1) goto <D.22579>; else goto <D.22580>;
              <D.22579>:
              D.22544 = field->type;
              D.22559 = D.22544->attrs;
              D.22560 = (int) D.22559;
              D.22581 = D.22560 & 16;
              if (D.22581 == 0) goto <D.22582>; else goto <D.22583>;
              <D.22582>:
              D.22553 = field->name;
              D.22584 = monoeg_g_strdup_printf ("Missing field layout info for %s", D.22553);
              mono_class_set_failure (class, 7, D.22584);
              goto <D.19306>;
              <D.22583>:
              <D.22580>:
              D.22578 = field->offset;
              if (D.22578 < -1) goto <D.22585>; else goto <D.22586>;
              <D.22585>:
              D.22578 = field->offset;
              D.22553 = field->name;
              D.22587 = monoeg_g_strdup_printf ("Invalid negative field offset %d for %s", D.22578, D.22553);
              mono_class_set_failure (class, 7, D.22587);
              goto <D.19306>;
              <D.22586>:
            }
          finally
            {
              offset = {CLOBBER};
            }
        }
        <D.22574>:
        <D.22572>:
        if (blittable != 0) goto <D.22588>; else goto <D.22589>;
        <D.22588>:
        D.22544 = field->type;
        D.22559 = D.22544->attrs;
        D.22560 = (int) D.22559;
        D.22581 = D.22560 & 16;
        if (D.22581 == 0) goto <D.22590>; else goto <D.22591>;
        <D.22590>:
        D.22544 = field->type;
        D.22595 = BIT_FIELD_REF <*D.22544, 64, 64>;
        D.22596 = D.22595 & 8589934592;
        if (D.22596 != 0) goto <D.22592>; else goto <D.22597>;
        <D.22597>:
        D.22544 = field->type;
        D.22598 = mono_type_is_reference (D.22544);
        if (D.22598 != 0) goto <D.22592>; else goto <D.22593>;
        <D.22592>:
        blittable = 0;
        goto <D.22594>;
        <D.22593>:
        {
          struct MonoClass * field_class;

          D.22544 = field->type;
          field_class = mono_class_from_mono_type (D.22544);
          if (field_class != 0B) goto <D.22599>; else goto <D.22600>;
          <D.22599>:
          mono_class_setup_fields (field_class);
          D.22601 = field_class->exception_type;
          if (D.22601 != 0) goto <D.22602>; else goto <D.22603>;
          <D.22602>:
          mono_class_set_failure (class, 7, 0B);
          goto <D.19306>;
          <D.22603>:
          <D.22600>:
          if (field_class == 0B) goto <D.22604>; else goto <D.22606>;
          <D.22606>:
          D.22607 = BIT_FIELD_REF <*field_class, 64, 256>;
          D.22608 = D.22607 & 288230376151711744;
          if (D.22608 == 0) goto <D.22604>; else goto <D.22605>;
          <D.22604>:
          blittable = 0;
          <D.22605>:
        }
        <D.22594>:
        <D.22591>:
        <D.22589>:
        D.22456 = BIT_FIELD_REF <*class, 64, 256>;
        D.22609 = D.22456 & 576460752303423488;
        if (D.22609 != 0) goto <D.22610>; else goto <D.22611>;
        <D.22610>:
        D.22544 = field->type;
        D.22559 = D.22544->attrs;
        D.22560 = (int) D.22559;
        D.22581 = D.22560 & 16;
        if (D.22581 == 0) goto <D.22612>; else goto <D.22613>;
        <D.22612>:
        D.22544 = field->type;
        D.22614 = mono_class_from_mono_type (D.22544);
        class->element_class = D.22614;
        D.22615 = class->element_class;
        class->cast_class = D.22615;
        D.22615 = class->element_class;
        D.22616 = D.22615->blittable;
        blittable = (int) D.22616;
        <D.22613>:
        <D.22611>:
        D.22544 = field->type;
        D.22617 = mono_type_has_exceptions (D.22544);
        if (D.22617 != 0) goto <D.22618>; else goto <D.22619>;
        <D.22618>:
        {
          char * class_name;
          char * type_name;

          class_name = mono_type_get_full_name (class);
          D.22544 = field->type;
          type_name = mono_type_full_name (D.22544);
          mono_class_set_failure (class, 7, 0B);
          D.22553 = field->name;
          monoeg_g_log (0B, 16, "Invalid type %s for instance field %s:%s", type_name, class_name, D.22553);
          monoeg_g_free (class_name);
          monoeg_g_free (type_name);
          goto <D.19306>;
        }
        <D.22619>:
      }
      <D.19303>:
      i = i + 1;
      <D.19311>:
      if (i < top) goto <D.19310>; else goto <D.19306>;
      <D.19306>:
      D.22620 = mono_defaults.string_class;
      if (D.22620 == class) goto <D.22621>; else goto <D.22622>;
      <D.22621>:
      blittable = 0;
      <D.22622>:
      D.22523 = (unsigned char) blittable;
      D.22524 = (<unnamed-unsigned:1>) D.22523;
      class->blittable = D.22524;
      D.22456 = BIT_FIELD_REF <*class, 64, 256>;
      D.22609 = D.22456 & 576460752303423488;
      if (D.22609 != 0) goto <D.22623>; else goto <D.22624>;
      <D.22623>:
      D.22625 = mono_class_enum_basetype (class);
      if (D.22625 == 0B) goto <D.22626>; else goto <D.22627>;
      <D.22626>:
      mono_class_set_failure (class, 7, 0B);
      return;
      <D.22627>:
      <D.22624>:
      if (explicit_size != 0) goto <D.22628>; else goto <D.22629>;
      <D.22628>:
      real_size.46 = real_size;
      if (real_size.46 != 0) goto <D.22630>; else goto <D.22631>;
      <D.22630>:
      D.22491 = class->instance_size;
      D.22512 = (unsigned int) D.22491;
      real_size.46 = real_size;
      D.22521 = MAX_EXPR <D.22512, real_size.46>;
      D.22522 = (int) D.22521;
      class->instance_size = D.22522;
      <D.22631>:
      <D.22629>:
      D.22632 = class->exception_type;
      if (D.22632 != 0) goto <D.22633>; else goto <D.22634>;
      <D.22633>:
      return;
      <D.22634>:
      mono_class_layout_fields (class);
      D.22456 = BIT_FIELD_REF <*class, 64, 256>;
      D.22635 = D.22456 & 1152921504606846976;
      if (D.22635 != 0) goto <D.22636>; else goto <D.22637>;
      <D.22636>:
      D.22491 = class->instance_size;
      D.22638 = (unsigned int) D.22491;
      D.22639 = D.22638 + 4294967295;
      if (D.22639 > 1048591) goto <D.22640>; else goto <D.22641>;
      <D.22640>:
      mono_class_set_failure (class, 7, 0B);
      <D.22641>:
      <D.22637>:
      mono_memory_barrier ();
      class->fields_inited = 1;
    }
  finally
    {
      error = {CLOBBER};
      real_size = {CLOBBER};
      packing_size = {CLOBBER};
    }
}


mono_class_setup_basic_field_info (struct MonoClass * class)
{
  struct MonoClassField * D.22647;
  struct MonoClass * iftmp.52;
  struct MonoGenericClass * D.22651;
  unsigned int D.22655;
  struct MonoClass * D.22658;
  struct MonoImage * D.22659;
  long unsigned int D.22660;
  long unsigned int D.22661;
  long unsigned int D.22664;
  long unsigned int D.22665;
  unsigned int D.22670;
  unsigned int D.22671;
  unsigned int top.53;
  unsigned int D.22673;
  int D.22674;
  void * D.22675;
  long unsigned int D.22676;
  long unsigned int D.22677;
  struct MonoClassField * D.22680;
  struct MonoClassField * D.22681;
  const char * D.22682;
  unsigned int D.22684;
  unsigned int i.54;
  unsigned int D.22686;
  const char * D.22687;
  struct MonoClassField * field;
  struct MonoClass * gtd;
  struct MonoImage * image;
  int i;
  int top;

  D.22647 = class->fields;
  if (D.22647 != 0B) goto <D.22648>; else goto <D.22649>;
  <D.22648>:
  return;
  <D.22649>:
  D.22651 = class->generic_class;
  if (D.22651 != 0B) goto <D.22652>; else goto <D.22653>;
  <D.22652>:
  iftmp.52 = mono_class_get_generic_type_definition (class);
  goto <D.22654>;
  <D.22653>:
  iftmp.52 = 0B;
  <D.22654>:
  gtd = iftmp.52;
  image = class->image;
  D.22655 = class->field.count;
  top = (int) D.22655;
  D.22651 = class->generic_class;
  if (D.22651 != 0B) goto <D.22656>; else goto <D.22657>;
  <D.22656>:
  D.22651 = class->generic_class;
  D.22658 = D.22651->container_class;
  D.22659 = D.22658->image;
  D.22660 = BIT_FIELD_REF <*D.22659, 64, 192>;
  D.22661 = D.22660 & 268435456;
  if (D.22661 != 0) goto <D.22662>; else goto <D.22663>;
  <D.22662>:
  D.22651 = class->generic_class;
  D.22658 = D.22651->container_class;
  D.22664 = BIT_FIELD_REF <*D.22658, 64, 256>;
  D.22665 = D.22664 & 72057594037927936;
  if (D.22665 == 0) goto <D.22666>; else goto <D.22667>;
  <D.22666>:
  return;
  <D.22667>:
  <D.22663>:
  <D.22657>:
  if (gtd != 0B) goto <D.22668>; else goto <D.22669>;
  <D.22668>:
  mono_class_setup_basic_field_info (gtd);
  D.22670 = gtd->field.count;
  top = (int) D.22670;
  D.22671 = gtd->field.first;
  class->field.first = D.22671;
  D.22670 = gtd->field.count;
  class->field.count = D.22670;
  <D.22669>:
  top.53 = (unsigned int) top;
  D.22673 = top.53 * 32;
  D.22674 = (int) D.22673;
  D.22675 = mono_class_alloc0 (class, D.22674);
  class->fields = D.22675;
  i = 0;
  goto <D.19283>;
  <D.19282>:
  D.22647 = class->fields;
  D.22676 = (long unsigned int) i;
  D.22677 = D.22676 * 32;
  field = D.22647 + D.22677;
  field->parent = class;
  if (gtd != 0B) goto <D.22678>; else goto <D.22679>;
  <D.22678>:
  D.22680 = gtd->fields;
  D.22676 = (long unsigned int) i;
  D.22677 = D.22676 * 32;
  D.22681 = D.22680 + D.22677;
  D.22682 = mono_field_get_name (D.22681);
  field->name = D.22682;
  goto <D.22683>;
  <D.22679>:
  {
    int idx;
    guint32 name_idx;

    D.22684 = class->field.first;
    i.54 = (unsigned int) i;
    D.22686 = D.22684 + i.54;
    idx = (int) D.22686;
    name_idx = mono_metadata_decode_table_row_col (image, 4, idx, 1);
    D.22687 = mono_metadata_string_heap (image, name_idx);
    field->name = D.22687;
  }
  <D.22683>:
  i = i + 1;
  <D.19283>:
  if (i < top) goto <D.19282>; else goto <D.19284>;
  <D.19284>:
}


mono_class_alloc0 (struct MonoClass * class, int size)
{
  long unsigned int D.22689;
  void * D.22690;
  void * res;

  res = mono_class_alloc (class, size);
  D.22689 = (long unsigned int) size;
  memset (res, 0, D.22689);
  D.22690 = res;
  return D.22690;
}


mono_class_alloc (struct MonoClass * class, int size)
{
  struct MonoGenericClass * D.22692;
  void * D.22695;
  struct MonoImageSet * D.22696;
  unsigned int size.55;
  struct MonoImage * D.22698;

  D.22692 = class->generic_class;
  if (D.22692 != 0B) goto <D.22693>; else goto <D.22694>;
  <D.22693>:
  D.22692 = class->generic_class;
  D.22696 = D.22692->owner;
  size.55 = (unsigned int) size;
  D.22695 = mono_image_set_alloc (D.22696, size.55);
  return D.22695;
  <D.22694>:
  D.22698 = class->image;
  size.55 = (unsigned int) size;
  D.22695 = mono_image_alloc (D.22698, size.55);
  return D.22695;
}


__attribute__((__artificial__, __gnu_inline__, __always_inline__, __nothrow__, __leaf__))
memset (void * __dest, int __ch, size_t __len)
{
  void * D.22700;
  long unsigned int D.22701;

  D.22701 = __builtin_object_size (__dest, 0);
  D.22700 = __builtin___memset_chk (__dest, __ch, __len, D.22701);
  return D.22700;
}


mono_field_resolve_type (struct MonoClassField * field, struct MonoError * error)
{
  struct MonoClass * iftmp.56;
  struct MonoGenericClass * D.22704;
  long int field.57;
  struct MonoClassField * D.22709;
  long int D.22710;
  long int D.22711;
  long int D.22712;
  struct MonoClassField * D.22715;
  long unsigned int D.22716;
  long unsigned int D.22717;
  int D.22718;
  const char * D.22721;
  struct MonoGenericContext * D.22722;
  struct MonoType * D.22723;
  int D.22724;
  const char * D.22727;
  unsigned int D.22729;
  unsigned int field_idx.58;
  unsigned int D.22731;
  long unsigned int D.22732;
  long unsigned int D.22733;
  _Bool D.22734;
  long int D.22735;
  long int D.22736;
  struct MonoGenericContainer * D.22739;
  _Bool D.22745;
  long int D.22746;
  long int D.22747;
  unsigned int D.22750;
  int D.22751;
  const char * D.22754;
  const char * sig.59;
  const char * sig.60;
  char D.22757;
  _Bool D.22758;
  long int D.22759;
  long int D.22760;
  unsigned int D.22763;
  short int D.22764;
  const char * D.22765;
  struct MonoType * D.22766;
  struct MonoType * D.22767;
  gchar * D.22770;
  struct MonoClass * class;
  struct MonoImage * image;
  struct MonoClass * gtd;
  int field_idx;

  class = field->parent;
  image = class->image;
  D.22704 = class->generic_class;
  if (D.22704 != 0B) goto <D.22705>; else goto <D.22706>;
  <D.22705>:
  iftmp.56 = mono_class_get_generic_type_definition (class);
  goto <D.22707>;
  <D.22706>:
  iftmp.56 = 0B;
  <D.22707>:
  gtd = iftmp.56;
  field.57 = (long int) field;
  D.22709 = class->fields;
  D.22710 = (long int) D.22709;
  D.22711 = field.57 - D.22710;
  D.22712 = D.22711 /[ex] 32;
  field_idx = (int) D.22712;
  mono_error_init (error);
  if (gtd != 0B) goto <D.22713>; else goto <D.22714>;
  <D.22713>:
  {
    struct MonoClassField * gfield;
    struct MonoType * gtype;

    D.22715 = gtd->fields;
    D.22716 = (long unsigned int) field_idx;
    D.22717 = D.22716 * 32;
    gfield = D.22715 + D.22717;
    gtype = mono_field_get_type_checked (gfield, error);
    D.22718 = mono_error_ok (error);
    if (D.22718 == 0) goto <D.22719>; else goto <D.22720>;
    <D.22719>:
    {
      char * err_msg;

      D.22721 = mono_error_get_message (error);
      err_msg = monoeg_g_strdup_printf ("Could not load field %d type due to: %s", field_idx, D.22721);
      mono_class_set_failure (class, 7, err_msg);
      monoeg_g_free (err_msg);
    }
    <D.22720>:
    D.22722 = mono_class_get_context (class);
    D.22723 = mono_class_inflate_generic_type_no_copy (image, gtype, D.22722, error);
    field->type = D.22723;
    D.22724 = mono_error_ok (error);
    if (D.22724 == 0) goto <D.22725>; else goto <D.22726>;
    <D.22725>:
    {
      char * err_msg;

      D.22727 = mono_error_get_message (error);
      err_msg = monoeg_g_strdup_printf ("Could not load field %d type due to: %s", field_idx, D.22727);
      mono_class_set_failure (class, 7, err_msg);
      monoeg_g_free (err_msg);
    }
    <D.22726>:
  }
  goto <D.22728>;
  <D.22714>:
  {
    const char * sig;
    guint32 cols[3];
    struct MonoGenericContainer * container;
    int idx;

    try
      {
        container = 0B;
        D.22729 = class->field.first;
        field_idx.58 = (unsigned int) field_idx;
        D.22731 = D.22729 + field_idx.58;
        idx = (int) D.22731;
        D.22732 = BIT_FIELD_REF <*image, 64, 192>;
        D.22733 = D.22732 & 268435456;
        D.22734 = D.22733 != 0;
        D.22735 = (long int) D.22734;
        D.22736 = __builtin_expect (D.22735, 0);
        if (D.22736 != 0) goto <D.22737>; else goto <D.22738>;
        <D.22737>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "class.c", 10119, "!image->dynamic");
        <D.22738>:
        D.22739 = class->generic_container;
        if (D.22739 != 0B) goto <D.22740>; else goto <D.22741>;
        <D.22740>:
        container = class->generic_container;
        goto <D.22742>;
        <D.22741>:
        if (gtd != 0B) goto <D.22743>; else goto <D.22744>;
        <D.22743>:
        container = gtd->generic_container;
        D.22745 = container == 0B;
        D.22746 = (long int) D.22745;
        D.22747 = __builtin_expect (D.22746, 0);
        if (D.22747 != 0) goto <D.22748>; else goto <D.22749>;
        <D.22748>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "class.c", 10125, "container");
        <D.22749>:
        <D.22744>:
        <D.22742>:
        mono_metadata_decode_table_row (image, 4, idx, &cols, 3);
        D.22750 = cols[2];
        D.22751 = mono_verifier_verify_field_signature (image, D.22750, 0B);
        if (D.22751 == 0) goto <D.22752>; else goto <D.22753>;
        <D.22752>:
        D.22754 = field->name;
        mono_error_set_type_load_class (error, class, "Could not verify field %s signature", D.22754);
        mono_class_set_failure (class, 7, 0B);
        return;
        <D.22753>:
        D.22750 = cols[2];
        sig.59 = mono_metadata_blob_heap (image, D.22750);
        sig = sig.59;
        sig.60 = sig;
        mono_metadata_decode_value (sig.60, &sig);
        sig.60 = sig;
        D.22757 = *sig.60;
        D.22758 = D.22757 != 6;
        D.22759 = (long int) D.22758;
        D.22760 = __builtin_expect (D.22759, 0);
        if (D.22760 != 0) goto <D.22761>; else goto <D.22762>;
        <D.22761>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "class.c", 10141, "*sig == 0x06");
        <D.22762>:
        D.22763 = cols[0];
        D.22764 = (short int) D.22763;
        sig.60 = sig;
        D.22765 = sig.60 + 1;
        D.22766 = mono_metadata_parse_type_full (image, container, 5, D.22764, D.22765, &sig);
        field->type = D.22766;
        D.22767 = field->type;
        if (D.22767 == 0B) goto <D.22768>; else goto <D.22769>;
        <D.22768>:
        D.22754 = field->name;
        D.22770 = monoeg_g_strdup_printf ("Could not load field %s type", D.22754);
        mono_class_set_failure_from_loader_error (class, error, D.22770);
        <D.22769>:
      }
    finally
      {
        sig = {CLOBBER};
        cols = {CLOBBER};
      }
  }
  <D.22728>:
}


mono_class_inflate_generic_type_no_copy (struct MonoImage * image, struct MonoType * type, struct MonoGenericContext * context, struct MonoError * error)
{
  int D.22776;
  struct MonoType * D.22779;
  long unsigned int D.22782;
  long unsigned int D.22783;
  struct MonoType * inflated;

  inflated = 0B;
  mono_error_init (error);
  if (context != 0B) goto <D.22774>; else goto <D.22775>;
  <D.22774>:
  inflated = inflate_generic_type (image, type, context, error);
  D.22776 = mono_error_ok (error);
  if (D.22776 == 0) goto <D.22777>; else goto <D.22778>;
  <D.22777>:
  D.22779 = 0B;
  return D.22779;
  <D.22778>:
  <D.22775>:
  if (inflated == 0B) goto <D.22780>; else goto <D.22781>;
  <D.22780>:
  D.22779 = type;
  return D.22779;
  <D.22781>:
  D.22782 = mono_stats.inflated_type_count;
  D.22783 = D.22782 + 1;
  mono_stats.inflated_type_count = D.22783;
  D.22779 = inflated;
  return D.22779;
}


mono_type_has_exceptions (struct MonoType * type)
{
  unsigned char D.22785;
  int D.22786;
  gboolean D.22787;
  struct MonoClass * D.22788;
  unsigned char D.22789;
  struct MonoArrayType * D.22790;
  struct MonoClass * D.22791;
  unsigned char D.22792;
  struct MonoGenericClass * D.22793;
  struct MonoClass * D.22794;
  unsigned char D.22795;

  D.22785 = type->type;
  D.22786 = (int) D.22785;
  switch (D.22786) <default: <D.22796>, case 17: <D.19259>, case 18: <D.19258>, case 20: <D.19261>, case 21: <D.19262>, case 29: <D.19260>>
  <D.19258>:
  <D.19259>:
  <D.19260>:
  D.22788 = type->data.klass;
  D.22789 = D.22788->exception_type;
  D.22787 = (gboolean) D.22789;
  return D.22787;
  <D.19261>:
  D.22790 = type->data.array;
  D.22791 = D.22790->eklass;
  D.22792 = D.22791->exception_type;
  D.22787 = (gboolean) D.22792;
  return D.22787;
  <D.19262>:
  D.22793 = type->data.generic_class;
  D.22794 = mono_generic_class_get_class (D.22793);
  D.22795 = D.22794->exception_type;
  D.22787 = (gboolean) D.22795;
  return D.22787;
  <D.22796>:
  D.22787 = 0;
  return D.22787;
}


mono_memory_barrier ()
{
  __sync_synchronize ();
}


__attribute__((visibility ("hidden")))
mono_type_get_basic_type_from_generic (struct MonoType * type)
{
  long unsigned int D.22800;
  long unsigned int D.22801;
  unsigned char D.22804;
  struct MonoType * D.22806;
  struct MonoClass * D.22807;

  D.22800 = BIT_FIELD_REF <*type, 64, 64>;
  D.22801 = D.22800 & 8589934592;
  if (D.22801 == 0) goto <D.22802>; else goto <D.22803>;
  <D.22802>:
  D.22804 = type->type;
  if (D.22804 == 19) goto <D.22798>; else goto <D.22805>;
  <D.22805>:
  D.22804 = type->type;
  if (D.22804 == 30) goto <D.22798>; else goto <D.22799>;
  <D.22798>:
  D.22807 = mono_defaults.object_class;
  D.22806 = &D.22807->byval_arg;
  return D.22806;
  <D.22799>:
  <D.22803>:
  D.22806 = type;
  return D.22806;
}


__attribute__((visibility ("hidden")))
mono_class_layout_fields (struct MonoClass * class)
{
  unsigned int D.22809;
  unsigned int D.22810;
  long unsigned int D.22813;
  long unsigned int D.22814;
  struct MonoClassField * D.22817;
  long unsigned int D.22818;
  long unsigned int D.22819;
  struct MonoType * D.22820;
  short unsigned int D.22821;
  int D.22822;
  int D.22823;
  int D.22829;
  int D.22831;
  unsigned char D.22833;
  struct MonoImage * D.22835;
  struct MonoImage * D.22836;
  int D.22837;
  struct MonoClass * D.22839;
  int D.22840;
  int D.22846;
  int D.22848;
  unsigned char D.22850;
  int D.22852;
  struct MonoClass * D.22854;
  int D.22855;
  int D.22859;
  int D.22861;
  unsigned char D.22863;
  int D.22865;
  struct MonoClass * D.22867;
  int D.22868;
  struct MonoClass * D.22877;
  unsigned char D.22880;
  int D.22883;
  int D.22885;
  const char * D.22888;
  int D.22889;
  int D.22900;
  int D.22902;
  unsigned char D.22904;
  int D.22906;
  struct MonoClass * D.22908;
  int D.22909;
  int D.22916;
  const char * D.22919;
  int D.22920;
  int D.22923;
  int iftmp.61;
  long unsigned int D.22925;
  <unnamed-unsigned:4> D.22928;
  int D.22929;
  int align.62;
  int D.22935;
  int D.22937;
  int D.22940;
  struct MonoClass * D.22942;
  int D.22943;
  unsigned int align.63;
  unsigned int D.22945;
  int align.64;
  unsigned char D.22947;
  int D.22948;
  int D.22949;
  unsigned char D.22950;
  int real_size.65;
  int D.22954;
  int D.22955;
  int D.22956;
  int D.22957;
  int D.22958;
  int iftmp.66;
  long unsigned int D.22962;
  long unsigned int D.22963;
  _Bool D.22966;
  long int D.22967;
  long int D.22968;
  unsigned int D.22971;
  unsigned int D.22972;
  unsigned int D.22973;
  int D.22974;
  int D.22975;
  int D.22976;
  int D.22979;
  int D.22980;
  int D.22981;
  const char * D.22984;
  int D.22985;
  int D.22990;
  int iftmp.67;
  int align.68;
  int D.22996;
  unsigned char D.22997;
  unsigned int D.22998;
  unsigned int D.22999;
  int D.23000;
  int D.23003;
  int D.23005;
  struct MonoClass * D.23007;
  int D.23008;
  long unsigned int D.23009;
  long unsigned int D.23010;
  unsigned int D.23013;
  unsigned int D.23019;
  long unsigned int D.23022;
  long unsigned int D.23023;
  long unsigned int D.23024;
  long unsigned int D.23025;
  unsigned char D.23026;
  unsigned int D.23027;
  unsigned int D.23028;
  const char * D.23033;
  int D.23034;
  int D.23037;
  int D.23040;
  int D.23041;
  int align.69;
  int D.23043;
  int D.23044;
  int D.23045;
  int D.23046;
  unsigned int D.23047;
  int D.23048;
  int i;
  const int top;
  guint32 layout;
  guint32 pass;
  guint32 passes;
  guint32 real_size;
  gboolean gc_aware_layout;
  struct MonoClassField * field;

  D.22809 = class->field.count;
  top = (const int) D.22809;
  D.22810 = class->flags;
  layout = D.22810 & 24;
  gc_aware_layout = 0;
  if (layout == 0) goto <D.22811>; else goto <D.22812>;
  <D.22811>:
  D.22813 = BIT_FIELD_REF <*class, 64, 256>;
  D.22814 = D.22813 & 1152921504606846976;
  if (D.22814 == 0) goto <D.22815>; else goto <D.22816>;
  <D.22815>:
  gc_aware_layout = 1;
  <D.22816>:
  <D.22812>:
  i = 0;
  goto <D.19334>;
  <D.19333>:
  {
    struct MonoType * ftype;

    D.22817 = class->fields;
    D.22818 = (long unsigned int) i;
    D.22819 = D.22818 * 32;
    field = D.22817 + D.22819;
    D.22820 = field->type;
    D.22821 = D.22820->attrs;
    D.22822 = (int) D.22821;
    D.22823 = D.22822 & 16;
    if (D.22823 == 0) goto <D.22824>; else goto <D.22825>;
    <D.22824>:
    D.22820 = field->type;
    ftype = mono_type_get_underlying_type (D.22820);
    ftype = mono_type_get_basic_type_from_generic (ftype);
    D.22829 = mono_type_is_reference (ftype);
    if (D.22829 != 0) goto <D.22826>; else goto <D.22830>;
    <D.22830>:
    D.22831 = mono_gc_is_moving ();
    if (D.22831 == 0) goto <D.22832>; else goto <D.22827>;
    <D.22832>:
    D.22833 = ftype->type;
    if (D.22833 == 25) goto <D.22834>; else goto <D.22827>;
    <D.22834>:
    D.22835 = class->image;
    D.22836 = mono_defaults.corlib;
    if (D.22835 == D.22836) goto <D.22826>; else goto <D.22827>;
    <D.22827>:
    D.22837 = mono_type_is_struct (ftype);
    if (D.22837 != 0) goto <D.22838>; else goto <D.22828>;
    <D.22838>:
    D.22839 = mono_class_from_mono_type (ftype);
    D.22840 = mono_class_has_references (D.22839);
    if (D.22840 != 0) goto <D.22826>; else goto <D.22828>;
    <D.22826>:
    class->has_references = 1;
    <D.22828>:
    <D.22825>:
  }
  i = i + 1;
  <D.19334>:
  if (i < top) goto <D.19333>; else goto <D.19335>;
  <D.19335>:
  i = 0;
  goto <D.19338>;
  <D.19337>:
  {
    struct MonoType * ftype;

    D.22817 = class->fields;
    D.22818 = (long unsigned int) i;
    D.22819 = D.22818 * 32;
    field = D.22817 + D.22819;
    D.22820 = field->type;
    D.22821 = D.22820->attrs;
    D.22822 = (int) D.22821;
    D.22823 = D.22822 & 16;
    if (D.22823 != 0) goto <D.22841>; else goto <D.22842>;
    <D.22841>:
    D.22820 = field->type;
    ftype = mono_type_get_underlying_type (D.22820);
    ftype = mono_type_get_basic_type_from_generic (ftype);
    D.22846 = mono_type_is_reference (ftype);
    if (D.22846 != 0) goto <D.22843>; else goto <D.22847>;
    <D.22847>:
    D.22848 = mono_gc_is_moving ();
    if (D.22848 == 0) goto <D.22849>; else goto <D.22844>;
    <D.22849>:
    D.22850 = ftype->type;
    if (D.22850 == 25) goto <D.22851>; else goto <D.22844>;
    <D.22851>:
    D.22835 = class->image;
    D.22836 = mono_defaults.corlib;
    if (D.22835 == D.22836) goto <D.22843>; else goto <D.22844>;
    <D.22844>:
    D.22852 = mono_type_is_struct (ftype);
    if (D.22852 != 0) goto <D.22853>; else goto <D.22845>;
    <D.22853>:
    D.22854 = mono_class_from_mono_type (ftype);
    D.22855 = mono_class_has_references (D.22854);
    if (D.22855 != 0) goto <D.22843>; else goto <D.22845>;
    <D.22843>:
    class->has_static_refs = 1;
    <D.22845>:
    <D.22842>:
  }
  i = i + 1;
  <D.19338>:
  if (i < top) goto <D.19337>; else goto <D.19339>;
  <D.19339>:
  i = 0;
  goto <D.19342>;
  <D.19341>:
  {
    struct MonoType * ftype;

    D.22817 = class->fields;
    D.22818 = (long unsigned int) i;
    D.22819 = D.22818 * 32;
    field = D.22817 + D.22819;
    D.22820 = field->type;
    ftype = mono_type_get_underlying_type (D.22820);
    ftype = mono_type_get_basic_type_from_generic (ftype);
    D.22859 = mono_type_is_reference (ftype);
    if (D.22859 != 0) goto <D.22856>; else goto <D.22860>;
    <D.22860>:
    D.22861 = mono_gc_is_moving ();
    if (D.22861 == 0) goto <D.22862>; else goto <D.22857>;
    <D.22862>:
    D.22863 = ftype->type;
    if (D.22863 == 25) goto <D.22864>; else goto <D.22857>;
    <D.22864>:
    D.22835 = class->image;
    D.22836 = mono_defaults.corlib;
    if (D.22835 == D.22836) goto <D.22856>; else goto <D.22857>;
    <D.22857>:
    D.22865 = mono_type_is_struct (ftype);
    if (D.22865 != 0) goto <D.22866>; else goto <D.22858>;
    <D.22866>:
    D.22867 = mono_class_from_mono_type (ftype);
    D.22868 = mono_class_has_references (D.22867);
    if (D.22868 != 0) goto <D.22856>; else goto <D.22858>;
    <D.22856>:
    D.22820 = field->type;
    D.22821 = D.22820->attrs;
    D.22822 = (int) D.22821;
    D.22823 = D.22822 & 16;
    if (D.22823 != 0) goto <D.22869>; else goto <D.22870>;
    <D.22869>:
    class->has_static_refs = 1;
    goto <D.22871>;
    <D.22870>:
    class->has_references = 1;
    <D.22871>:
    <D.22858>:
  }
  i = i + 1;
  <D.19342>:
  if (i < top) goto <D.19341>; else goto <D.19343>;
  <D.19343>:
  switch (layout) <default: <D.23016>, case 0: <D.19344>, case 8: <D.19345>, case 16: <D.19357>>
  <D.19344>:
  <D.19345>:
  if (gc_aware_layout != 0) goto <D.22872>; else goto <D.22873>;
  <D.22872>:
  passes = 2;
  goto <D.22874>;
  <D.22873>:
  passes = 1;
  <D.22874>:
  if (layout != 0) goto <D.22875>; else goto <D.22876>;
  <D.22875>:
  passes = 1;
  <D.22876>:
  D.22877 = class->parent;
  if (D.22877 != 0B) goto <D.22878>; else goto <D.22879>;
  <D.22878>:
  D.22877 = class->parent;
  mono_class_setup_fields (D.22877);
  D.22877 = class->parent;
  D.22880 = D.22877->exception_type;
  if (D.22880 != 0) goto <D.22881>; else goto <D.22882>;
  <D.22881>:
  mono_class_set_failure (class, 7, 0B);
  return;
  <D.22882>:
  D.22877 = class->parent;
  D.22883 = D.22877->instance_size;
  real_size = (guint32) D.22883;
  goto <D.22884>;
  <D.22879>:
  real_size = 16;
  <D.22884>:
  pass = 0;
  goto <D.19354>;
  <D.19353>:
  i = 0;
  goto <D.19351>;
  <D.19350>:
  {
    gint32 align;
    guint32 size;
    struct MonoType * ftype;

    try
      {
        D.22817 = class->fields;
        D.22818 = (long unsigned int) i;
        D.22819 = D.22818 * 32;
        field = D.22817 + D.22819;
        D.22820 = field->type;
        D.22821 = D.22820->attrs;
        D.22822 = (int) D.22821;
        D.22885 = D.22822 & 1536;
        if (D.22885 != 0) goto <D.22886>; else goto <D.22887>;
        <D.22886>:
        D.22888 = mono_field_get_name (field);
        D.22889 = strcmp (D.22888, "_Deleted");
        if (D.22889 == 0) goto <D.22890>; else goto <D.22891>;
        <D.22890>:
        // predicted unlikely by continue predictor.
        goto <D.19349>;
        <D.22891>:
        <D.22887>:
        D.22820 = field->type;
        D.22821 = D.22820->attrs;
        D.22822 = (int) D.22821;
        D.22823 = D.22822 & 16;
        if (D.22823 != 0) goto <D.22892>; else goto <D.22893>;
        <D.22892>:
        // predicted unlikely by continue predictor.
        goto <D.19349>;
        <D.22893>:
        D.22820 = field->type;
        ftype = mono_type_get_underlying_type (D.22820);
        ftype = mono_type_get_basic_type_from_generic (ftype);
        if (gc_aware_layout != 0) goto <D.22894>; else goto <D.22895>;
        <D.22894>:
        D.22900 = mono_type_is_reference (ftype);
        if (D.22900 != 0) goto <D.22896>; else goto <D.22901>;
        <D.22901>:
        D.22902 = mono_gc_is_moving ();
        if (D.22902 == 0) goto <D.22903>; else goto <D.22897>;
        <D.22903>:
        D.22904 = ftype->type;
        if (D.22904 == 25) goto <D.22905>; else goto <D.22897>;
        <D.22905>:
        D.22835 = class->image;
        D.22836 = mono_defaults.corlib;
        if (D.22835 == D.22836) goto <D.22896>; else goto <D.22897>;
        <D.22897>:
        D.22906 = mono_type_is_struct (ftype);
        if (D.22906 != 0) goto <D.22907>; else goto <D.22898>;
        <D.22907>:
        D.22908 = mono_class_from_mono_type (ftype);
        D.22909 = mono_class_has_references (D.22908);
        if (D.22909 != 0) goto <D.22896>; else goto <D.22898>;
        <D.22896>:
        if (pass == 1) goto <D.22910>; else goto <D.22911>;
        <D.22910>:
        // predicted unlikely by continue predictor.
        goto <D.19349>;
        <D.22911>:
        goto <D.22899>;
        <D.22898>:
        if (pass == 0) goto <D.22912>; else goto <D.22913>;
        <D.22912>:
        // predicted unlikely by continue predictor.
        goto <D.19349>;
        <D.22913>:
        <D.22899>:
        <D.22895>:
        if (top == 1) goto <D.22914>; else goto <D.22915>;
        <D.22914>:
        D.22916 = class->instance_size;
        if (D.22916 == 16) goto <D.22917>; else goto <D.22918>;
        <D.22917>:
        D.22919 = mono_field_get_name (field);
        D.22920 = strcmp (D.22919, "$PRIVATE$");
        if (D.22920 == 0) goto <D.22921>; else goto <D.22922>;
        <D.22921>:
        // predicted unlikely by continue predictor.
        goto <D.19349>;
        <D.22922>:
        <D.22918>:
        <D.22915>:
        D.22820 = field->type;
        D.22923 = mono_type_size (D.22820, &align);
        size = (guint32) D.22923;
        D.22813 = BIT_FIELD_REF <*class, 64, 256>;
        D.22925 = D.22813 & 263882790666240;
        if (D.22925 != 0) goto <D.22926>; else goto <D.22927>;
        <D.22926>:
        D.22928 = class->packing_size;
        D.22929 = (int) D.22928;
        align.62 = align;
        iftmp.61 = MIN_EXPR <D.22929, align.62>;
        goto <D.22931>;
        <D.22927>:
        iftmp.61 = align;
        <D.22931>:
        align = iftmp.61;
        D.22935 = mono_type_is_reference (ftype);
        if (D.22935 != 0) goto <D.22932>; else goto <D.22936>;
        <D.22936>:
        D.22937 = mono_gc_is_moving ();
        if (D.22937 == 0) goto <D.22938>; else goto <D.22933>;
        <D.22938>:
        D.22904 = ftype->type;
        if (D.22904 == 25) goto <D.22939>; else goto <D.22933>;
        <D.22939>:
        D.22835 = class->image;
        D.22836 = mono_defaults.corlib;
        if (D.22835 == D.22836) goto <D.22932>; else goto <D.22933>;
        <D.22933>:
        D.22940 = mono_type_is_struct (ftype);
        if (D.22940 != 0) goto <D.22941>; else goto <D.22934>;
        <D.22941>:
        D.22942 = mono_class_from_mono_type (ftype);
        D.22943 = mono_class_has_references (D.22942);
        if (D.22943 != 0) goto <D.22932>; else goto <D.22934>;
        <D.22932>:
        align.62 = align;
        align.63 = (unsigned int) align.62;
        D.22945 = MAX_EXPR <align.63, 8>;
        align.64 = (int) D.22945;
        align = align.64;
        <D.22934>:
        D.22947 = class->min_align;
        D.22948 = (int) D.22947;
        align.62 = align;
        D.22949 = MAX_EXPR <D.22948, align.62>;
        D.22950 = (unsigned char) D.22949;
        class->min_align = D.22950;
        real_size.65 = (int) real_size;
        field->offset = real_size.65;
        align.62 = align;
        if (align.62 != 0) goto <D.22952>; else goto <D.22953>;
        <D.22952>:
        D.22954 = field->offset;
        align.62 = align;
        D.22955 = align.62 + -1;
        D.22956 = D.22954 + D.22955;
        field->offset = D.22956;
        D.22954 = field->offset;
        align.62 = align;
        D.22957 = -align.62;
        D.22958 = D.22954 & D.22957;
        field->offset = D.22958;
        <D.22953>:
        D.22835 = class->image;
        D.22962 = BIT_FIELD_REF <*D.22835, 64, 192>;
        D.22963 = D.22962 & 268435456;
        if (D.22963 == 0) goto <D.22964>; else goto <D.22960>;
        <D.22964>:
        D.22954 = field->offset;
        if (D.22954 <= 0) goto <D.22965>; else goto <D.22960>;
        <D.22965>:
        iftmp.66 = 1;
        goto <D.22961>;
        <D.22960>:
        iftmp.66 = 0;
        <D.22961>:
        D.22966 = iftmp.66 != 0;
        D.22967 = (long int) D.22966;
        D.22968 = __builtin_expect (D.22967, 0);
        if (D.22968 != 0) goto <D.22969>; else goto <D.22970>;
        <D.22969>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "class.c", 1894, "class->image->dynamic || field->offset > 0");
        <D.22970>:
        D.22954 = field->offset;
        D.22971 = (unsigned int) D.22954;
        real_size = D.22971 + size;
      }
    finally
      {
        align = {CLOBBER};
      }
  }
  <D.19349>:
  i = i + 1;
  <D.19351>:
  if (i < top) goto <D.19350>; else goto <D.19352>;
  <D.19352>:
  D.22916 = class->instance_size;
  D.22972 = (unsigned int) D.22916;
  D.22973 = MAX_EXPR <D.22972, real_size>;
  D.22974 = (int) D.22973;
  class->instance_size = D.22974;
  D.22916 = class->instance_size;
  D.22947 = class->min_align;
  D.22948 = (int) D.22947;
  D.22975 = D.22948 + -1;
  D.22976 = D.22916 & D.22975;
  if (D.22976 != 0) goto <D.22977>; else goto <D.22978>;
  <D.22977>:
  D.22916 = class->instance_size;
  D.22947 = class->min_align;
  D.22948 = (int) D.22947;
  D.22975 = D.22948 + -1;
  D.22979 = D.22916 + D.22975;
  class->instance_size = D.22979;
  D.22916 = class->instance_size;
  D.22947 = class->min_align;
  D.22948 = (int) D.22947;
  D.22980 = -D.22948;
  D.22981 = D.22916 & D.22980;
  class->instance_size = D.22981;
  <D.22978>:
  pass = pass + 1;
  <D.19354>:
  if (pass < passes) goto <D.19353>; else goto <D.19355>;
  <D.19355>:
  goto <D.19356>;
  <D.19357>:
  real_size = 0;
  i = 0;
  goto <D.19363>;
  <D.19362>:
  {
    gint32 align;
    guint32 size;
    struct MonoType * ftype;

    try
      {
        D.22817 = class->fields;
        D.22818 = (long unsigned int) i;
        D.22819 = D.22818 * 32;
        field = D.22817 + D.22819;
        D.22820 = field->type;
        D.22821 = D.22820->attrs;
        D.22822 = (int) D.22821;
        D.22885 = D.22822 & 1536;
        if (D.22885 != 0) goto <D.22982>; else goto <D.22983>;
        <D.22982>:
        D.22984 = mono_field_get_name (field);
        D.22985 = strcmp (D.22984, "_Deleted");
        if (D.22985 == 0) goto <D.22986>; else goto <D.22987>;
        <D.22986>:
        // predicted unlikely by continue predictor.
        goto <D.19361>;
        <D.22987>:
        <D.22983>:
        D.22820 = field->type;
        D.22821 = D.22820->attrs;
        D.22822 = (int) D.22821;
        D.22823 = D.22822 & 16;
        if (D.22823 != 0) goto <D.22988>; else goto <D.22989>;
        <D.22988>:
        // predicted unlikely by continue predictor.
        goto <D.19361>;
        <D.22989>:
        D.22820 = field->type;
        D.22990 = mono_type_size (D.22820, &align);
        size = (guint32) D.22990;
        D.22813 = BIT_FIELD_REF <*class, 64, 256>;
        D.22925 = D.22813 & 263882790666240;
        if (D.22925 != 0) goto <D.22992>; else goto <D.22993>;
        <D.22992>:
        D.22928 = class->packing_size;
        D.22929 = (int) D.22928;
        align.68 = align;
        iftmp.67 = MIN_EXPR <D.22929, align.68>;
        goto <D.22995>;
        <D.22993>:
        iftmp.67 = align;
        <D.22995>:
        align = iftmp.67;
        D.22947 = class->min_align;
        D.22948 = (int) D.22947;
        align.68 = align;
        D.22996 = MAX_EXPR <D.22948, align.68>;
        D.22997 = (unsigned char) D.22996;
        class->min_align = D.22997;
        D.22954 = field->offset;
        D.22998 = (unsigned int) D.22954;
        D.22999 = D.22998 + 16;
        D.23000 = (int) D.22999;
        field->offset = D.23000;
        D.22820 = field->type;
        ftype = mono_type_get_underlying_type (D.22820);
        ftype = mono_type_get_basic_type_from_generic (ftype);
        D.23003 = mono_type_is_reference (ftype);
        if (D.23003 != 0) goto <D.23001>; else goto <D.23004>;
        <D.23004>:
        D.23005 = mono_type_is_struct (ftype);
        if (D.23005 != 0) goto <D.23006>; else goto <D.23002>;
        <D.23006>:
        D.23007 = mono_class_from_mono_type (ftype);
        D.23008 = mono_class_has_references (D.23007);
        if (D.23008 != 0) goto <D.23001>; else goto <D.23002>;
        <D.23001>:
        D.22954 = field->offset;
        D.23009 = (long unsigned int) D.22954;
        D.23010 = D.23009 & 7;
        if (D.23010 != 0) goto <D.23011>; else goto <D.23012>;
        <D.23011>:
        mono_class_set_failure (class, 7, 0B);
        <D.23012>:
        <D.23002>:
        D.22954 = field->offset;
        D.22971 = (unsigned int) D.22954;
        D.23013 = D.22971 + size;
        real_size = MAX_EXPR <D.23013, real_size>;
      }
    finally
      {
        align = {CLOBBER};
      }
  }
  <D.19361>:
  i = i + 1;
  <D.19363>:
  if (i < top) goto <D.19362>; else goto <D.19364>;
  <D.19364>:
  D.22916 = class->instance_size;
  D.22972 = (unsigned int) D.22916;
  D.22973 = MAX_EXPR <D.22972, real_size>;
  D.22974 = (int) D.22973;
  class->instance_size = D.22974;
  D.22916 = class->instance_size;
  D.22947 = class->min_align;
  D.22948 = (int) D.22947;
  D.22975 = D.22948 + -1;
  D.22976 = D.22916 & D.22975;
  if (D.22976 != 0) goto <D.23014>; else goto <D.23015>;
  <D.23014>:
  D.22916 = class->instance_size;
  D.22947 = class->min_align;
  D.22948 = (int) D.22947;
  D.22975 = D.22948 + -1;
  D.22979 = D.22916 + D.22975;
  class->instance_size = D.22979;
  D.22916 = class->instance_size;
  D.22947 = class->min_align;
  D.22948 = (int) D.22947;
  D.22980 = -D.22948;
  D.22981 = D.22916 & D.22980;
  class->instance_size = D.22981;
  <D.23015>:
  goto <D.19356>;
  <D.23016>:
  <D.19356>:
  if (layout != 16) goto <D.23017>; else goto <D.23018>;
  <D.23017>:
  D.22916 = class->instance_size;
  D.23019 = (unsigned int) D.22916;
  if (D.23019 <= 24) goto <D.23020>; else goto <D.23021>;
  <D.23020>:
  D.22916 = class->instance_size;
  D.23022 = (long unsigned int) D.22916;
  D.23023 = D.23022 + 18446744073709551600;
  D.22947 = class->min_align;
  D.23024 = (long unsigned int) D.22947;
  D.23025 = MAX_EXPR <D.23023, D.23024>;
  D.23026 = (unsigned char) D.23025;
  class->min_align = D.23026;
  <D.23021>:
  <D.23018>:
  mono_memory_barrier ();
  class->size_inited = 1;
  i = 0;
  goto <D.19370>;
  <D.19369>:
  {
    gint32 align;
    guint32 size;

    try
      {
        D.22817 = class->fields;
        D.22818 = (long unsigned int) i;
        D.22819 = D.22818 * 32;
        field = D.22817 + D.22819;
        D.22820 = field->type;
        D.22821 = D.22820->attrs;
        D.23027 = (unsigned int) D.22821;
        D.23028 = D.23027 & 80;
        if (D.23028 != 16) goto <D.23029>; else goto <D.23030>;
        <D.23029>:
        // predicted unlikely by continue predictor.
        goto <D.19367>;
        <D.23030>:
        D.22820 = field->type;
        D.22821 = D.22820->attrs;
        D.22822 = (int) D.22821;
        D.22885 = D.22822 & 1536;
        if (D.22885 != 0) goto <D.23031>; else goto <D.23032>;
        <D.23031>:
        D.23033 = mono_field_get_name (field);
        D.23034 = strcmp (D.23033, "_Deleted");
        if (D.23034 == 0) goto <D.23035>; else goto <D.23036>;
        <D.23035>:
        // predicted unlikely by continue predictor.
        goto <D.19367>;
        <D.23036>:
        <D.23032>:
        D.22820 = field->type;
        D.23037 = mono_type_has_exceptions (D.22820);
        if (D.23037 != 0) goto <D.23038>; else goto <D.23039>;
        <D.23038>:
        mono_class_set_failure (class, 7, 0B);
        goto <D.19368>;
        <D.23039>:
        D.22820 = field->type;
        D.23040 = mono_type_size (D.22820, &align);
        size = (guint32) D.23040;
        D.23041 = class->sizes.class_size;
        field->offset = D.23041;
        D.22954 = field->offset;
        align.69 = align;
        D.23043 = align.69 + -1;
        D.23044 = D.22954 + D.23043;
        field->offset = D.23044;
        D.22954 = field->offset;
        align.69 = align;
        D.23045 = -align.69;
        D.23046 = D.22954 & D.23045;
        field->offset = D.23046;
        D.22954 = field->offset;
        D.22971 = (unsigned int) D.22954;
        D.23047 = D.22971 + size;
        D.23048 = (int) D.23047;
        class->sizes.class_size = D.23048;
      }
    finally
      {
        align = {CLOBBER};
      }
  }
  <D.19367>:
  i = i + 1;
  <D.19370>:
  if (i < top) goto <D.19369>; else goto <D.19368>;
  <D.19368>:
}


mono_class_has_references (struct MonoClass * klass)
{
  long unsigned int D.23057;
  long unsigned int D.23058;
  gboolean D.23061;
  <unnamed-unsigned:1> D.23062;

  D.23057 = BIT_FIELD_REF <*klass, 64, 256>;
  D.23058 = D.23057 & 4611686018427387904;
  if (D.23058 != 0) goto <D.23059>; else goto <D.23060>;
  <D.23059>:
  D.23061 = 1;
  return D.23061;
  <D.23060>:
  mono_class_init (klass);
  D.23062 = klass->has_references;
  D.23061 = (gboolean) D.23062;
  return D.23061;
}


__attribute__((visibility ("hidden")))
mono_class_setup_methods (struct MonoClass * class)
{
  struct MonoMethod * * D.23064;
  struct MonoGenericClass * D.23069;
  unsigned char D.23072;
  gchar * D.23077;
  unsigned int D.23078;
  unsigned int D.23079;
  unsigned int D.23080;
  unsigned int D.23081;
  int D.23082;
  long unsigned int D.23083;
  long unsigned int D.23084;
  struct MonoMethod * * D.23085;
  struct MonoMethod * * D.23086;
  struct MonoMethod * * D.23087;
  struct MonoMethod * D.23088;
  struct MonoGenericContext * D.23089;
  struct MonoMethod * D.23090;
  int D.23091;
  const char * D.23094;
  gchar * D.23095;
  unsigned int i.70;
  unsigned char D.23098;
  guint32 iftmp.71;
  int D.23105;
  _Bool D.23106;
  long int D.23107;
  long int D.23108;
  short unsigned int D.23111;
  int D.23114;
  int D.23115;
  unsigned int D.23116;
  unsigned int D.23117;
  unsigned int D.23118;
  int D.23119;
  struct MonoImage * D.23120;
  unsigned int D.23121;
  struct MonoClass * D.23122;
  struct MonoType * D.23123;
  struct MonoClass * D.23124;
  struct MonoType * D.23125;
  int D.23126;
  int method_num.72;
  long unsigned int D.23128;
  long unsigned int D.23129;
  struct MonoMethod * * D.23130;
  int D.23133;
  unsigned int D.23134;
  int method_num.73;
  long unsigned int D.23136;
  long unsigned int D.23137;
  struct MonoMethod * * D.23138;
  struct MonoClass * D.23139;
  struct MonoType * D.23140;
  int method_num.74;
  long unsigned int D.23142;
  long unsigned int D.23143;
  struct MonoMethod * * D.23144;
  struct MonoType * D.23145;
  int method_num.75;
  long unsigned int D.23147;
  long unsigned int D.23148;
  struct MonoMethod * * D.23149;
  int D.23150;
  unsigned int D.23151;
  int method_num.76;
  long unsigned int D.23153;
  long unsigned int D.23154;
  struct MonoMethod * * D.23155;
  struct MonoClass * * D.23156;
  struct MonoClass * * D.23157;
  struct MonoClass * D.23158;
  int D.23159;
  int D.23160;
  unsigned int D.23162;
  unsigned int D.23163;
  unsigned int D.23164;
  unsigned int D.23165;
  int D.23166;
  unsigned int D.23167;
  struct MonoMethod * D.23168;
  unsigned int D.23171;
  unsigned int D.23172;
  unsigned char D.23174;
  struct MonoMethod * D.23176;
  short unsigned int D.23177;
  int D.23178;
  int D.23179;
  int slot.77;
  short int D.23183;
  int i;
  struct MonoMethod * * methods;

  D.23064 = class->methods;
  if (D.23064 != 0B) goto <D.23065>; else goto <D.23066>;
  <D.23065>:
  return;
  <D.23066>:
  mono_loader_lock ();
  D.23064 = class->methods;
  if (D.23064 != 0B) goto <D.23067>; else goto <D.23068>;
  <D.23067>:
  mono_loader_unlock ();
  return;
  <D.23068>:
  D.23069 = class->generic_class;
  if (D.23069 != 0B) goto <D.23070>; else goto <D.23071>;
  <D.23070>:
  {
    struct MonoError error;
    struct MonoClass * gklass;

    try
      {
        D.23069 = class->generic_class;
        gklass = D.23069->container_class;
        mono_class_init (gklass);
        D.23072 = gklass->exception_type;
        if (D.23072 == 0) goto <D.23073>; else goto <D.23074>;
        <D.23073>:
        mono_class_setup_methods (gklass);
        <D.23074>:
        D.23072 = gklass->exception_type;
        if (D.23072 != 0) goto <D.23075>; else goto <D.23076>;
        <D.23075>:
        D.23077 = monoeg_strdup ("Generic type definition failed to load");
        mono_class_set_failure (class, 7, D.23077);
        mono_loader_unlock ();
        return;
        <D.23076>:
        D.23078 = gklass->method.count;
        class->method.count = D.23078;
        D.23079 = class->method.count;
        D.23080 = D.23079 + 1;
        D.23081 = D.23080 * 8;
        D.23082 = (int) D.23081;
        methods = mono_class_alloc0 (class, D.23082);
        i = 0;
        goto <D.19386>;
        <D.19385>:
        D.23083 = (long unsigned int) i;
        D.23084 = D.23083 * 8;
        D.23085 = methods + D.23084;
        D.23086 = gklass->methods;
        D.23083 = (long unsigned int) i;
        D.23084 = D.23083 * 8;
        D.23087 = D.23086 + D.23084;
        D.23088 = *D.23087;
        D.23089 = mono_class_get_context (class);
        D.23090 = mono_class_inflate_generic_method_full_checked (D.23088, class, D.23089, &error);
        *D.23085 = D.23090;
        D.23091 = mono_error_ok (&error);
        if (D.23091 == 0) goto <D.23092>; else goto <D.23093>;
        <D.23092>:
        {
          char * method;

          D.23086 = gklass->methods;
          D.23083 = (long unsigned int) i;
          D.23084 = D.23083 * 8;
          D.23087 = D.23086 + D.23084;
          D.23088 = *D.23087;
          method = mono_method_full_name (D.23088, 1);
          D.23094 = mono_error_get_message (&error);
          D.23095 = monoeg_g_strdup_printf ("Could not inflate method %s due to %s", method, D.23094);
          mono_class_set_failure (class, 7, D.23095);
          monoeg_g_free (method);
          mono_error_cleanup (&error);
          mono_loader_unlock ();
          return;
        }
        <D.23093>:
        i = i + 1;
        <D.19386>:
        D.23079 = class->method.count;
        i.70 = (unsigned int) i;
        if (D.23079 > i.70) goto <D.19385>; else goto <D.19387>;
        <D.19387>:
      }
    finally
      {
        error = {CLOBBER};
      }
  }
  goto <D.23097>;
  <D.23071>:
  D.23098 = class->rank;
  if (D.23098 != 0) goto <D.23099>; else goto <D.23100>;
  <D.23099>:
  {
    struct MonoError error;
    struct MonoMethod * amethod;
    struct MonoMethodSignature * sig;
    int count_generic;
    int first_generic;
    int method_num;

    try
      {
        count_generic = 0;
        first_generic = 0;
        method_num = 0;
        D.23098 = class->rank;
        if (D.23098 > 1) goto <D.23102>; else goto <D.23103>;
        <D.23102>:
        iftmp.71 = 5;
        goto <D.23104>;
        <D.23103>:
        iftmp.71 = 4;
        <D.23104>:
        class->method.count = iftmp.71;
        mono_class_setup_interfaces (class, &error);
        D.23105 = mono_error_ok (&error);
        D.23106 = D.23105 == 0;
        D.23107 = (long int) D.23106;
        D.23108 = __builtin_expect (D.23107, 0);
        if (D.23108 != 0) goto <D.23109>; else goto <D.23110>;
        <D.23109>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "class.c", 2088, "mono_error_ok (&error)");
        <D.23110>:
        D.23111 = class->interface_count;
        if (D.23111 != 0) goto <D.23112>; else goto <D.23113>;
        <D.23112>:
        count_generic = generic_array_methods (class);
        D.23079 = class->method.count;
        first_generic = (int) D.23079;
        D.23079 = class->method.count;
        D.23111 = class->interface_count;
        D.23114 = (int) D.23111;
        D.23115 = D.23114 * count_generic;
        D.23116 = (unsigned int) D.23115;
        D.23117 = D.23079 + D.23116;
        class->method.count = D.23117;
        <D.23113>:
        D.23079 = class->method.count;
        D.23118 = D.23079 * 8;
        D.23119 = (int) D.23118;
        methods = mono_class_alloc0 (class, D.23119);
        D.23120 = class->image;
        D.23098 = class->rank;
        D.23121 = (unsigned int) D.23098;
        sig = mono_metadata_signature_alloc (D.23120, D.23121);
        D.23122 = mono_defaults.void_class;
        D.23123 = &D.23122->byval_arg;
        sig->ret = D.23123;
        sig->pinvoke = 1;
        sig->hasthis = 1;
        i = 0;
        goto <D.19395>;
        <D.19394>:
        D.23124 = mono_defaults.int32_class;
        D.23125 = &D.23124->byval_arg;
        sig->params[i] = D.23125;
        i = i + 1;
        <D.19395>:
        D.23098 = class->rank;
        D.23126 = (int) D.23098;
        if (D.23126 > i) goto <D.19394>; else goto <D.19396>;
        <D.19396>:
        amethod = create_array_method (class, ".ctor", sig);
        method_num.72 = method_num;
        method_num = method_num.72 + 1;
        D.23128 = (long unsigned int) method_num.72;
        D.23129 = D.23128 * 8;
        D.23130 = methods + D.23129;
        *D.23130 = amethod;
        D.23098 = class->rank;
        if (D.23098 > 1) goto <D.23131>; else goto <D.23132>;
        <D.23131>:
        D.23120 = class->image;
        D.23098 = class->rank;
        D.23126 = (int) D.23098;
        D.23133 = D.23126 * 2;
        D.23134 = (unsigned int) D.23133;
        sig = mono_metadata_signature_alloc (D.23120, D.23134);
        D.23122 = mono_defaults.void_class;
        D.23123 = &D.23122->byval_arg;
        sig->ret = D.23123;
        sig->pinvoke = 1;
        sig->hasthis = 1;
        i = 0;
        goto <D.19398>;
        <D.19397>:
        D.23124 = mono_defaults.int32_class;
        D.23125 = &D.23124->byval_arg;
        sig->params[i] = D.23125;
        i = i + 1;
        <D.19398>:
        D.23098 = class->rank;
        D.23126 = (int) D.23098;
        D.23133 = D.23126 * 2;
        if (D.23133 > i) goto <D.19397>; else goto <D.19399>;
        <D.19399>:
        amethod = create_array_method (class, ".ctor", sig);
        method_num.73 = method_num;
        method_num = method_num.73 + 1;
        D.23136 = (long unsigned int) method_num.73;
        D.23137 = D.23136 * 8;
        D.23138 = methods + D.23137;
        *D.23138 = amethod;
        <D.23132>:
        D.23120 = class->image;
        D.23098 = class->rank;
        D.23121 = (unsigned int) D.23098;
        sig = mono_metadata_signature_alloc (D.23120, D.23121);
        D.23139 = class->element_class;
        D.23140 = &D.23139->byval_arg;
        sig->ret = D.23140;
        sig->pinvoke = 1;
        sig->hasthis = 1;
        i = 0;
        goto <D.19401>;
        <D.19400>:
        D.23124 = mono_defaults.int32_class;
        D.23125 = &D.23124->byval_arg;
        sig->params[i] = D.23125;
        i = i + 1;
        <D.19401>:
        D.23098 = class->rank;
        D.23126 = (int) D.23098;
        if (D.23126 > i) goto <D.19400>; else goto <D.19402>;
        <D.19402>:
        amethod = create_array_method (class, "Get", sig);
        method_num.74 = method_num;
        method_num = method_num.74 + 1;
        D.23142 = (long unsigned int) method_num.74;
        D.23143 = D.23142 * 8;
        D.23144 = methods + D.23143;
        *D.23144 = amethod;
        D.23120 = class->image;
        D.23098 = class->rank;
        D.23121 = (unsigned int) D.23098;
        sig = mono_metadata_signature_alloc (D.23120, D.23121);
        D.23139 = class->element_class;
        D.23145 = &D.23139->this_arg;
        sig->ret = D.23145;
        sig->pinvoke = 1;
        sig->hasthis = 1;
        i = 0;
        goto <D.19404>;
        <D.19403>:
        D.23124 = mono_defaults.int32_class;
        D.23125 = &D.23124->byval_arg;
        sig->params[i] = D.23125;
        i = i + 1;
        <D.19404>:
        D.23098 = class->rank;
        D.23126 = (int) D.23098;
        if (D.23126 > i) goto <D.19403>; else goto <D.19405>;
        <D.19405>:
        amethod = create_array_method (class, "Address", sig);
        method_num.75 = method_num;
        method_num = method_num.75 + 1;
        D.23147 = (long unsigned int) method_num.75;
        D.23148 = D.23147 * 8;
        D.23149 = methods + D.23148;
        *D.23149 = amethod;
        D.23120 = class->image;
        D.23098 = class->rank;
        D.23126 = (int) D.23098;
        D.23150 = D.23126 + 1;
        D.23151 = (unsigned int) D.23150;
        sig = mono_metadata_signature_alloc (D.23120, D.23151);
        D.23122 = mono_defaults.void_class;
        D.23123 = &D.23122->byval_arg;
        sig->ret = D.23123;
        sig->pinvoke = 1;
        sig->hasthis = 1;
        i = 0;
        goto <D.19407>;
        <D.19406>:
        D.23124 = mono_defaults.int32_class;
        D.23125 = &D.23124->byval_arg;
        sig->params[i] = D.23125;
        i = i + 1;
        <D.19407>:
        D.23098 = class->rank;
        D.23126 = (int) D.23098;
        if (D.23126 > i) goto <D.19406>; else goto <D.19408>;
        <D.19408>:
        D.23139 = class->element_class;
        D.23140 = &D.23139->byval_arg;
        sig->params[i] = D.23140;
        amethod = create_array_method (class, "Set", sig);
        method_num.76 = method_num;
        method_num = method_num.76 + 1;
        D.23153 = (long unsigned int) method_num.76;
        D.23154 = D.23153 * 8;
        D.23155 = methods + D.23154;
        *D.23155 = amethod;
        i = 0;
        goto <D.19410>;
        <D.19409>:
        D.23156 = class->interfaces;
        D.23083 = (long unsigned int) i;
        D.23084 = D.23083 * 8;
        D.23157 = D.23156 + D.23084;
        D.23158 = *D.23157;
        D.23159 = i * count_generic;
        D.23160 = D.23159 + first_generic;
        setup_generic_array_ifaces (class, D.23158, methods, D.23160);
        i = i + 1;
        <D.19410>:
        D.23111 = class->interface_count;
        D.23114 = (int) D.23111;
        if (D.23114 > i) goto <D.19409>; else goto <D.19411>;
        <D.19411>:
      }
    finally
      {
        error = {CLOBBER};
      }
  }
  goto <D.23161>;
  <D.23100>:
  D.23079 = class->method.count;
  D.23118 = D.23079 * 8;
  D.23119 = (int) D.23118;
  methods = mono_class_alloc (class, D.23119);
  i = 0;
  goto <D.19414>;
  <D.19413>:
  {
    int idx;

    D.23120 = class->image;
    D.23162 = class->method.first;
    i.70 = (unsigned int) i;
    D.23163 = D.23162 + i.70;
    D.23164 = D.23163 + 1;
    D.23165 = mono_metadata_translate_token_index (D.23120, 6, D.23164);
    idx = (int) D.23165;
    D.23083 = (long unsigned int) i;
    D.23084 = D.23083 * 8;
    D.23085 = methods + D.23084;
    D.23120 = class->image;
    D.23166 = idx | 100663296;
    D.23167 = (unsigned int) D.23166;
    D.23168 = mono_get_method (D.23120, D.23167, class);
    *D.23085 = D.23168;
  }
  i = i + 1;
  <D.19414>:
  D.23079 = class->method.count;
  i.70 = (unsigned int) i;
  if (D.23079 > i.70) goto <D.19413>; else goto <D.19415>;
  <D.19415>:
  <D.23161>:
  <D.23097>:
  D.23171 = class->flags;
  D.23172 = D.23171 & 32;
  if (D.23172 != 0) goto <D.23169>; else goto <D.23173>;
  <D.23173>:
  D.23174 = class->byval_arg.type;
  if (D.23174 == 19) goto <D.23169>; else goto <D.23175>;
  <D.23175>:
  D.23174 = class->byval_arg.type;
  if (D.23174 == 30) goto <D.23169>; else goto <D.23170>;
  <D.23169>:
  {
    int slot;

    slot = 0;
    i = 0;
    goto <D.19418>;
    <D.19417>:
    D.23083 = (long unsigned int) i;
    D.23084 = D.23083 * 8;
    D.23085 = methods + D.23084;
    D.23176 = *D.23085;
    D.23177 = D.23176->flags;
    D.23178 = (int) D.23177;
    D.23179 = D.23178 & 64;
    if (D.23179 != 0) goto <D.23180>; else goto <D.23181>;
    <D.23180>:
    D.23083 = (long unsigned int) i;
    D.23084 = D.23083 * 8;
    D.23085 = methods + D.23084;
    D.23176 = *D.23085;
    slot.77 = slot;
    slot = slot.77 + 1;
    D.23183 = (short int) slot.77;
    D.23176->slot = D.23183;
    <D.23181>:
    i = i + 1;
    <D.19418>:
    D.23079 = class->method.count;
    i.70 = (unsigned int) i;
    if (D.23079 > i.70) goto <D.19417>; else goto <D.19419>;
    <D.19419>:
  }
  <D.23170>:
  mono_memory_barrier ();
  class->methods = methods;
  mono_loader_unlock ();
}


generic_array_methods (struct MonoClass * class)
{
  int generic_array_method_num.78;
  int D.23190;
  struct MonoClass * D.23191;
  unsigned char D.23192;
  _Bool D.23193;
  long int D.23194;
  long int D.23195;
  struct MonoMethod * * D.23198;
  long unsigned int D.23199;
  long unsigned int D.23200;
  struct MonoMethod * * D.23201;
  _Bool iftmp.79;
  long unsigned int D.23203;
  const char * D.23206;
  int D.23207;
  int D.23209;
  unsigned int D.23212;
  unsigned int i.80;
  struct MonoImage * D.23214;
  long unsigned int D.23215;
  unsigned int D.23216;
  unsigned int D.23217;
  void * D.23218;
  struct GenericArrayMethodInfo * generic_array_method_info.81;
  long unsigned int D.23220;
  struct GenericArrayMethodInfo * D.23221;
  _Bool iftmp.82;
  long unsigned int D.23223;
  const char * D.23226;
  int D.23227;
  int D.23229;
  _Bool iftmp.83;
  long unsigned int D.23234;
  int D.23237;
  int D.23239;
  long unsigned int D.23243;
  int D.23244;
  long unsigned int D.23247;
  long unsigned int D.23249;
  int D.23250;
  long unsigned int D.23253;
  _Bool iftmp.84;
  long unsigned int D.23256;
  int D.23259;
  int D.23261;
  long unsigned int D.23265;
  unsigned int D.23266;
  long unsigned int D.23267;
  unsigned int D.23268;
  unsigned int D.23269;
  unsigned int D.23270;
  long unsigned int D.23271;
  gchar * D.23272;
  int i;
  int count_generic;
  struct GList * list;
  struct GList * tmp;

  count_generic = 0;
  list = 0B;
  generic_array_method_num.78 = generic_array_method_num;
  if (generic_array_method_num.78 != 0) goto <D.23188>; else goto <D.23189>;
  <D.23188>:
  D.23190 = generic_array_method_num;
  return D.23190;
  <D.23189>:
  D.23191 = class->parent;
  mono_class_setup_methods (D.23191);
  D.23191 = class->parent;
  D.23192 = D.23191->exception_type;
  D.23193 = D.23192 != 0;
  D.23194 = (long int) D.23193;
  D.23195 = __builtin_expect (D.23194, 0);
  if (D.23195 != 0) goto <D.23196>; else goto <D.23197>;
  <D.23196>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "class.c", 4760, "!class->parent->exception_type");
  <D.23197>:
  i = 0;
  goto <D.20081>;
  <D.20080>:
  {
    struct MonoMethod * m;

    D.23191 = class->parent;
    D.23198 = D.23191->methods;
    D.23199 = (long unsigned int) i;
    D.23200 = D.23199 * 8;
    D.23201 = D.23198 + D.23200;
    m = *D.23201;
    D.23203 = __strlen_g ("InternalArray__");
    if (D.23203 <= 14) goto <D.23204>; else goto <D.23205>;
    <D.23204>:
    D.23206 = m->name;
    D.23207 = strcmp (D.23206, "InternalArray__");
    iftmp.79 = D.23207 == 0;
    goto <D.23208>;
    <D.23205>:
    D.23206 = m->name;
    D.23209 = strncmp (D.23206, "InternalArray__", 15);
    iftmp.79 = D.23209 == 0;
    <D.23208>:
    if (iftmp.79 != 0) goto <D.23210>; else goto <D.23211>;
    <D.23210>:
    count_generic = count_generic + 1;
    list = monoeg_g_list_prepend (list, m);
    <D.23211>:
  }
  i = i + 1;
  <D.20081>:
  D.23191 = class->parent;
  D.23212 = D.23191->method.count;
  i.80 = (unsigned int) i;
  if (D.23212 > i.80) goto <D.20080>; else goto <D.20082>;
  <D.20082>:
  list = monoeg_g_list_reverse (list);
  D.23214 = mono_defaults.corlib;
  D.23215 = (long unsigned int) count_generic;
  D.23216 = (unsigned int) D.23215;
  D.23217 = D.23216 * 16;
  D.23218 = mono_image_alloc (D.23214, D.23217);
  generic_array_method_info = D.23218;
  i = 0;
  tmp = list;
  goto <D.20090>;
  <D.20089>:
  {
    const char * mname;
    const char * iname;
    gchar * name;
    struct MonoMethod * m;
    const char * ireadonlylist_prefix;
    const char * ireadonlycollection_prefix;

    m = tmp->data;
    ireadonlylist_prefix = "InternalArray__IReadOnlyList_";
    ireadonlycollection_prefix = "InternalArray__IReadOnlyCollection_";
    generic_array_method_info.81 = generic_array_method_info;
    D.23199 = (long unsigned int) i;
    D.23220 = D.23199 * 16;
    D.23221 = generic_array_method_info.81 + D.23220;
    D.23221->array_method = m;
    D.23223 = __strlen_g ("InternalArray__ICollection_");
    if (D.23223 <= 26) goto <D.23224>; else goto <D.23225>;
    <D.23224>:
    D.23226 = m->name;
    D.23227 = strcmp (D.23226, "InternalArray__ICollection_");
    iftmp.82 = D.23227 == 0;
    goto <D.23228>;
    <D.23225>:
    D.23226 = m->name;
    D.23229 = strncmp (D.23226, "InternalArray__ICollection_", 27);
    iftmp.82 = D.23229 == 0;
    <D.23228>:
    if (iftmp.82 != 0) goto <D.23230>; else goto <D.23231>;
    <D.23230>:
    iname = "System.Collections.Generic.ICollection`1.";
    D.23226 = m->name;
    mname = D.23226 + 27;
    goto <D.23232>;
    <D.23231>:
    D.23234 = __strlen_g ("InternalArray__IEnumerable_");
    if (D.23234 <= 26) goto <D.23235>; else goto <D.23236>;
    <D.23235>:
    D.23226 = m->name;
    D.23237 = strcmp (D.23226, "InternalArray__IEnumerable_");
    iftmp.83 = D.23237 == 0;
    goto <D.23238>;
    <D.23236>:
    D.23226 = m->name;
    D.23239 = strncmp (D.23226, "InternalArray__IEnumerable_", 27);
    iftmp.83 = D.23239 == 0;
    <D.23238>:
    if (iftmp.83 != 0) goto <D.23240>; else goto <D.23241>;
    <D.23240>:
    iname = "System.Collections.Generic.IEnumerable`1.";
    D.23226 = m->name;
    mname = D.23226 + 27;
    goto <D.23242>;
    <D.23241>:
    D.23226 = m->name;
    D.23243 = __strlen_g (ireadonlylist_prefix);
    D.23244 = strncmp (D.23226, ireadonlylist_prefix, D.23243);
    if (D.23244 == 0) goto <D.23245>; else goto <D.23246>;
    <D.23245>:
    iname = "System.Collections.Generic.IReadOnlyList`1.";
    D.23226 = m->name;
    D.23247 = __strlen_g (ireadonlylist_prefix);
    mname = D.23226 + D.23247;
    goto <D.23248>;
    <D.23246>:
    D.23226 = m->name;
    D.23249 = __strlen_g (ireadonlycollection_prefix);
    D.23250 = strncmp (D.23226, ireadonlycollection_prefix, D.23249);
    if (D.23250 == 0) goto <D.23251>; else goto <D.23252>;
    <D.23251>:
    iname = "System.Collections.Generic.IReadOnlyCollection`1.";
    D.23226 = m->name;
    D.23253 = __strlen_g (ireadonlycollection_prefix);
    mname = D.23226 + D.23253;
    goto <D.23254>;
    <D.23252>:
    D.23256 = __strlen_g ("InternalArray__");
    if (D.23256 <= 14) goto <D.23257>; else goto <D.23258>;
    <D.23257>:
    D.23226 = m->name;
    D.23259 = strcmp (D.23226, "InternalArray__");
    iftmp.84 = D.23259 == 0;
    goto <D.23260>;
    <D.23258>:
    D.23226 = m->name;
    D.23261 = strncmp (D.23226, "InternalArray__", 15);
    iftmp.84 = D.23261 == 0;
    <D.23260>:
    if (iftmp.84 != 0) goto <D.23262>; else goto <D.23263>;
    <D.23262>:
    iname = "System.Collections.Generic.IList`1.";
    D.23226 = m->name;
    mname = D.23226 + 15;
    goto <D.23264>;
    <D.23263>:
    monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "class.c", 4795);
    <D.23264>:
    <D.23254>:
    <D.23248>:
    <D.23242>:
    <D.23232>:
    D.23214 = mono_defaults.corlib;
    D.23265 = __strlen_g (iname);
    D.23266 = (unsigned int) D.23265;
    D.23267 = __strlen_g (mname);
    D.23268 = (unsigned int) D.23267;
    D.23269 = D.23266 + D.23268;
    D.23270 = D.23269 + 1;
    name = mono_image_alloc (D.23214, D.23270);
    strcpy (name, iname);
    D.23271 = __strlen_g (iname);
    D.23272 = name + D.23271;
    strcpy (D.23272, mname);
    generic_array_method_info.81 = generic_array_method_info;
    D.23199 = (long unsigned int) i;
    D.23220 = D.23199 * 16;
    D.23221 = generic_array_method_info.81 + D.23220;
    D.23221->name = name;
    i = i + 1;
  }
  tmp = tmp->next;
  <D.20090>:
  if (tmp != 0B) goto <D.20089>; else goto <D.20091>;
  <D.20091>:
  generic_array_method_num = count_generic;
  monoeg_g_list_free (list);
  D.23190 = generic_array_method_num;
  return D.23190;
}


__attribute__((__artificial__, __gnu_inline__, __always_inline__, __nothrow__, __leaf__))
strcpy (char * restrict __dest, const char * restrict __src)
{
  char * D.23274;
  long unsigned int D.23275;

  D.23275 = __builtin_object_size (__dest, 1);
  D.23274 = __builtin___strcpy_chk (__dest, __src, D.23275);
  return D.23274;
}


create_array_method (struct MonoClass * class, const char * name, struct MonoMethodSignature * sig)
{
  struct MonoImage * D.23277;
  char D.23278;
  short unsigned int D.23281;
  short unsigned int D.23282;
  short unsigned int D.23284;
  short unsigned int D.23285;
  struct MonoMethod * D.23286;
  struct MonoMethod * method;

  D.23277 = class->image;
  method = mono_image_alloc0 (D.23277, 56);
  method->klass = class;
  method->flags = 6;
  method->iflags = 4096;
  method->signature = sig;
  method->name = name;
  method->slot = -1;
  D.23278 = *name;
  if (D.23278 == 46) goto <D.23279>; else goto <D.23280>;
  <D.23279>:
  D.23281 = method->flags;
  D.23282 = D.23281 | 6144;
  method->flags = D.23282;
  goto <D.23283>;
  <D.23280>:
  D.23284 = method->iflags;
  D.23285 = D.23284 | 3;
  method->iflags = D.23285;
  <D.23283>:
  D.23286 = method;
  return D.23286;
}


setup_generic_array_ifaces (struct MonoClass * class, struct MonoClass * iface, struct MonoMethod * * methods, int pos)
{
  struct MonoGenericClass * D.23288;
  struct MonoGenericInst * D.23289;
  struct GenericArrayMethodInfo * generic_array_method_info.85;
  long unsigned int D.23291;
  long unsigned int D.23292;
  struct GenericArrayMethodInfo * D.23293;
  int pos.86;
  long unsigned int D.23295;
  long unsigned int D.23296;
  struct MonoMethod * * D.23297;
  char * D.23298;
  struct MonoMethod * D.23299;
  int generic_array_method_num.87;
  struct MonoGenericContext tmp_context;
  int i;

  try
    {
      tmp_context.class_inst = 0B;
      D.23288 = iface->generic_class;
      D.23289 = D.23288->context.class_inst;
      tmp_context.method_inst = D.23289;
      i = 0;
      goto <D.20103>;
      <D.20102>:
      {
        struct MonoMethod * m;
        struct MonoMethod * inflated;

        generic_array_method_info.85 = generic_array_method_info;
        D.23291 = (long unsigned int) i;
        D.23292 = D.23291 * 16;
        D.23293 = generic_array_method_info.85 + D.23292;
        m = D.23293->array_method;
        inflated = mono_class_inflate_generic_method (m, &tmp_context);
        pos.86 = pos;
        pos = pos.86 + 1;
        D.23295 = (long unsigned int) pos.86;
        D.23296 = D.23295 * 8;
        D.23297 = methods + D.23296;
        generic_array_method_info.85 = generic_array_method_info;
        D.23291 = (long unsigned int) i;
        D.23292 = D.23291 * 16;
        D.23293 = generic_array_method_info.85 + D.23292;
        D.23298 = D.23293->name;
        D.23299 = mono_marshal_get_generic_array_helper (class, iface, D.23298, inflated);
        *D.23297 = D.23299;
      }
      i = i + 1;
      <D.20103>:
      generic_array_method_num.87 = generic_array_method_num;
      if (i < generic_array_method_num.87) goto <D.20102>; else goto <D.20104>;
      <D.20104>:
    }
  finally
    {
      tmp_context = {CLOBBER};
    }
}


__attribute__((visibility ("hidden")))
mono_class_get_method_by_index (struct MonoClass * class, int index)
{
  struct MonoGenericClass * D.23302;
  struct MonoMethod * * D.23304;
  struct MonoMethod * * D.23306;
  long unsigned int D.23307;
  long unsigned int D.23308;
  struct MonoMethod * * D.23309;
  struct MonoMethod * D.23310;
  struct MonoGenericContext * D.23311;
  struct MonoMethod * D.23312;
  unsigned char D.23313;
  int iftmp.88;
  unsigned int D.23321;
  unsigned int index.89;
  _Bool D.23323;
  long int D.23324;
  long int D.23325;
  struct MonoMethod * * D.23328;

  D.23302 = class->generic_class;
  if (D.23302 != 0B) goto <D.23303>; else goto <D.23301>;
  <D.23303>:
  D.23304 = class->methods;
  if (D.23304 == 0B) goto <D.23305>; else goto <D.23301>;
  <D.23305>:
  {
    struct MonoClass * gklass;
    struct MonoMethod * m;

    D.23302 = class->generic_class;
    gklass = D.23302->container_class;
    D.23306 = gklass->methods;
    D.23307 = (long unsigned int) index;
    D.23308 = D.23307 * 8;
    D.23309 = D.23306 + D.23308;
    D.23310 = *D.23309;
    D.23311 = mono_class_get_context (class);
    m = mono_class_inflate_generic_method_full (D.23310, class, D.23311);
    D.23312 = m;
    return D.23312;
  }
  <D.23301>:
  mono_class_setup_methods (class);
  D.23313 = class->exception_type;
  if (D.23313 != 0) goto <D.23314>; else goto <D.23315>;
  <D.23314>:
  D.23312 = 0B;
  return D.23312;
  <D.23315>:
  if (index < 0) goto <D.23317>; else goto <D.23320>;
  <D.23320>:
  D.23321 = class->method.count;
  index.89 = (unsigned int) index;
  if (D.23321 <= index.89) goto <D.23317>; else goto <D.23318>;
  <D.23317>:
  iftmp.88 = 1;
  goto <D.23319>;
  <D.23318>:
  iftmp.88 = 0;
  <D.23319>:
  D.23323 = iftmp.88 != 0;
  D.23324 = (long int) D.23323;
  D.23325 = __builtin_expect (D.23324, 0);
  if (D.23325 != 0) goto <D.23326>; else goto <D.23327>;
  <D.23326>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "class.c", 2205, "index >= 0 && index < class->method.count");
  <D.23327>:
  D.23304 = class->methods;
  D.23307 = (long unsigned int) index;
  D.23308 = D.23307 * 8;
  D.23328 = D.23304 + D.23308;
  D.23312 = *D.23328;
  return D.23312;
}


__attribute__((visibility ("hidden")))
mono_class_get_inflated_method (struct MonoClass * class, struct MonoMethod * method)
{
  struct MonoGenericClass * D.23330;
  struct MonoClass * D.23331;
  _Bool D.23332;
  long int D.23333;
  long int D.23334;
  unsigned char D.23337;
  _Bool D.23338;
  long int D.23339;
  long int D.23340;
  struct MonoMethod * * D.23343;
  long unsigned int D.23344;
  long unsigned int D.23345;
  struct MonoMethod * * D.23346;
  struct MonoMethod * D.23347;
  struct MonoMethod * * D.23350;
  struct MonoMethod * D.23353;
  struct MonoMethod * * D.23354;
  struct MonoGenericContext * D.23355;
  unsigned int D.23356;
  unsigned int i.90;
  struct MonoClass * gklass;
  int i;

  D.23330 = class->generic_class;
  gklass = D.23330->container_class;
  D.23331 = method->klass;
  D.23332 = D.23331 != gklass;
  D.23333 = (long int) D.23332;
  D.23334 = __builtin_expect (D.23333, 0);
  if (D.23334 != 0) goto <D.23335>; else goto <D.23336>;
  <D.23335>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "class.c", 2222, "method->klass == gklass");
  <D.23336>:
  mono_class_setup_methods (gklass);
  D.23337 = gklass->exception_type;
  D.23338 = D.23337 != 0;
  D.23339 = (long int) D.23338;
  D.23340 = __builtin_expect (D.23339, 0);
  if (D.23340 != 0) goto <D.23341>; else goto <D.23342>;
  <D.23341>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "class.c", 2225, "!gklass->exception_type");
  <D.23342>:
  i = 0;
  goto <D.19433>;
  <D.19432>:
  D.23343 = gklass->methods;
  D.23344 = (long unsigned int) i;
  D.23345 = D.23344 * 8;
  D.23346 = D.23343 + D.23345;
  D.23347 = *D.23346;
  if (D.23347 == method) goto <D.23348>; else goto <D.23349>;
  <D.23348>:
  D.23350 = class->methods;
  if (D.23350 != 0B) goto <D.23351>; else goto <D.23352>;
  <D.23351>:
  D.23350 = class->methods;
  D.23344 = (long unsigned int) i;
  D.23345 = D.23344 * 8;
  D.23354 = D.23350 + D.23345;
  D.23353 = *D.23354;
  return D.23353;
  <D.23352>:
  D.23343 = gklass->methods;
  D.23344 = (long unsigned int) i;
  D.23345 = D.23344 * 8;
  D.23346 = D.23343 + D.23345;
  D.23347 = *D.23346;
  D.23355 = mono_class_get_context (class);
  D.23353 = mono_class_inflate_generic_method_full (D.23347, class, D.23355);
  return D.23353;
  <D.23349>:
  i = i + 1;
  <D.19433>:
  D.23356 = gklass->method.count;
  i.90 = (unsigned int) i;
  if (D.23356 > i.90) goto <D.19432>; else goto <D.19434>;
  <D.19434>:
  D.23353 = 0B;
  return D.23353;
}


__attribute__((visibility ("hidden")))
mono_class_get_vtable_entry (struct MonoClass * class, int offset)
{
  unsigned char D.23359;
  struct MonoClass * D.23362;
  int D.23363;
  struct MonoMethod * D.23366;
  struct MonoMethod * * D.23367;
  long unsigned int D.23368;
  long unsigned int D.23369;
  struct MonoMethod * * D.23370;
  struct MonoGenericClass * D.23371;
  struct MonoMethod * * D.23374;
  struct MonoMethod * * D.23375;
  struct MonoGenericContext * D.23376;
  unsigned char D.23378;
  struct MonoMethod * * D.23381;
  struct MonoMethod * * D.23382;
  struct MonoMethod * m;

  D.23359 = class->rank;
  if (D.23359 == 1) goto <D.23360>; else goto <D.23361>;
  <D.23360>:
  D.23362 = class->parent;
  mono_class_setup_vtable (D.23362);
  D.23362 = class->parent;
  D.23363 = D.23362->vtable_size;
  if (D.23363 > offset) goto <D.23364>; else goto <D.23365>;
  <D.23364>:
  D.23362 = class->parent;
  D.23367 = D.23362->vtable;
  D.23368 = (long unsigned int) offset;
  D.23369 = D.23368 * 8;
  D.23370 = D.23367 + D.23369;
  D.23366 = *D.23370;
  return D.23366;
  <D.23365>:
  <D.23361>:
  D.23371 = class->generic_class;
  if (D.23371 != 0B) goto <D.23372>; else goto <D.23373>;
  <D.23372>:
  {
    struct MonoClass * gklass;

    D.23371 = class->generic_class;
    gklass = D.23371->container_class;
    mono_class_setup_vtable (gklass);
    D.23374 = gklass->vtable;
    D.23368 = (long unsigned int) offset;
    D.23369 = D.23368 * 8;
    D.23375 = D.23374 + D.23369;
    m = *D.23375;
    D.23376 = mono_class_get_context (class);
    m = mono_class_inflate_generic_method_full (m, class, D.23376);
  }
  goto <D.23377>;
  <D.23373>:
  mono_class_setup_vtable (class);
  D.23378 = class->exception_type;
  if (D.23378 != 0) goto <D.23379>; else goto <D.23380>;
  <D.23379>:
  D.23366 = 0B;
  return D.23366;
  <D.23380>:
  D.23381 = class->vtable;
  D.23368 = (long unsigned int) offset;
  D.23369 = D.23368 * 8;
  D.23382 = D.23381 + D.23369;
  m = *D.23382;
  <D.23377>:
  D.23366 = m;
  return D.23366;
}


__attribute__((visibility ("hidden")))
mono_class_get_vtable_size (struct MonoClass * klass)
{
  int D.23384;

  mono_class_setup_vtable (klass);
  D.23384 = klass->vtable_size;
  return D.23384;
}


__attribute__((visibility ("hidden")))
mono_unload_interface_ids (struct MonoBitSet * bitset)
{
  struct MonoBitSet * global_interface_bitset.91;

  mono_loader_lock ();
  global_interface_bitset.91 = global_interface_bitset;
  mono_bitset_sub (global_interface_bitset.91, bitset);
  mono_loader_unlock ();
}


__attribute__((visibility ("hidden")))
mono_unload_interface_id (struct MonoClass * class)
{
  struct MonoBitSet * global_interface_bitset.92;
  short unsigned int D.23390;
  unsigned int D.23393;

  global_interface_bitset.92 = global_interface_bitset;
  if (global_interface_bitset.92 != 0B) goto <D.23388>; else goto <D.23389>;
  <D.23388>:
  D.23390 = class->interface_id;
  if (D.23390 != 0) goto <D.23391>; else goto <D.23392>;
  <D.23391>:
  mono_loader_lock ();
  global_interface_bitset.92 = global_interface_bitset;
  D.23390 = class->interface_id;
  D.23393 = (unsigned int) D.23390;
  mono_bitset_clear (global_interface_bitset.92, D.23393);
  mono_loader_unlock ();
  <D.23392>:
  <D.23389>:
}


__attribute__((visibility ("hidden")))
mono_class_get_implemented_interfaces (struct MonoClass * klass, struct MonoError * error)
{
  int D.23394;
  struct GPtrArray * res.93;
  struct GPtrArray * D.23400;
  struct GPtrArray * res;

  try
    {
      res = 0B;
      collect_implemented_interfaces_aux (klass, &res, error);
      D.23394 = mono_error_ok (error);
      if (D.23394 == 0) goto <D.23395>; else goto <D.23396>;
      <D.23395>:
      res.93 = res;
      if (res.93 != 0B) goto <D.23398>; else goto <D.23399>;
      <D.23398>:
      res.93 = res;
      monoeg_g_ptr_array_free (res.93, 1);
      <D.23399>:
      D.23400 = 0B;
      return D.23400;
      <D.23396>:
      D.23400 = res;
      return D.23400;
    }
  finally
    {
      res = {CLOBBER};
    }
}


collect_implemented_interfaces_aux (struct MonoClass * klass, struct GPtrArray * * res, struct MonoError * error)
{
  int D.23403;
  struct MonoClass * * D.23406;
  long unsigned int D.23407;
  long unsigned int D.23408;
  struct MonoClass * * D.23409;
  struct GPtrArray * D.23410;
  struct GPtrArray * D.23413;
  unsigned char D.23414;
  int D.23417;
  short unsigned int D.23420;
  int D.23421;
  int i;
  struct MonoClass * ic;

  mono_class_setup_interfaces (klass, error);
  D.23403 = mono_error_ok (error);
  if (D.23403 == 0) goto <D.23404>; else goto <D.23405>;
  <D.23404>:
  return;
  <D.23405>:
  i = 0;
  goto <D.19549>;
  <D.19548>:
  D.23406 = klass->interfaces;
  D.23407 = (long unsigned int) i;
  D.23408 = D.23407 * 8;
  D.23409 = D.23406 + D.23408;
  ic = *D.23409;
  D.23410 = *res;
  if (D.23410 == 0B) goto <D.23411>; else goto <D.23412>;
  <D.23411>:
  D.23413 = monoeg_g_ptr_array_new ();
  *res = D.23413;
  <D.23412>:
  D.23410 = *res;
  monoeg_g_ptr_array_add (D.23410, ic);
  mono_class_init (ic);
  D.23414 = ic->exception_type;
  if (D.23414 != 0) goto <D.23415>; else goto <D.23416>;
  <D.23415>:
  mono_error_set_type_load_class (error, ic, "Error Loading class");
  return;
  <D.23416>:
  collect_implemented_interfaces_aux (ic, res, error);
  D.23417 = mono_error_ok (error);
  if (D.23417 == 0) goto <D.23418>; else goto <D.23419>;
  <D.23418>:
  return;
  <D.23419>:
  i = i + 1;
  <D.19549>:
  D.23420 = klass->interface_count;
  D.23421 = (int) D.23420;
  if (D.23421 > i) goto <D.19548>; else goto <D.19550>;
  <D.19550>:
}


mono_class_interface_offset (struct MonoClass * klass, struct MonoClass * itf)
{
  struct MonoClass * * D.23423;
  short unsigned int D.23424;
  long unsigned int D.23425;
  int D.23428;
  guint16 * D.23429;
  long int result.94;
  long int D.23431;
  long int D.23432;
  long int D.23433;
  long unsigned int D.23434;
  long unsigned int D.23435;
  guint16 * D.23436;
  short unsigned int D.23437;
  struct MonoClass * * result;

  D.23423 = klass->interfaces_packed;
  D.23424 = klass->interface_offsets_count;
  D.23425 = (long unsigned int) D.23424;
  result = mono_binary_search (itf, D.23423, D.23425, 8, compare_interface_ids);
  if (result != 0B) goto <D.23426>; else goto <D.23427>;
  <D.23426>:
  D.23429 = klass->interface_offsets_packed;
  result.94 = (long int) result;
  D.23423 = klass->interfaces_packed;
  D.23431 = (long int) D.23423;
  D.23432 = result.94 - D.23431;
  D.23433 = D.23432 /[ex] 8;
  D.23434 = (long unsigned int) D.23433;
  D.23435 = D.23434 * 2;
  D.23436 = D.23429 + D.23435;
  D.23437 = *D.23436;
  D.23428 = (int) D.23437;
  return D.23428;
  <D.23427>:
  D.23428 = -1;
  return D.23428;
}


compare_interface_ids (const void * p_key, const void * p_element)
{
  int D.23439;
  short unsigned int D.23440;
  int D.23441;
  short unsigned int D.23442;
  int D.23443;
  const struct MonoClass * key;
  const struct MonoClass * element;

  key = p_key;
  element = MEM[(struct MonoClass * *)p_element];
  D.23440 = key->interface_id;
  D.23441 = (int) D.23440;
  D.23442 = element->interface_id;
  D.23443 = (int) D.23442;
  D.23439 = D.23441 - D.23443;
  return D.23439;
}


__attribute__((visibility ("hidden")))
mono_class_interface_offset_with_variance (struct MonoClass * klass, struct MonoClass * itf, gboolean * non_exact_match)
{
  int D.23447;
  int D.23448;
  struct MonoClass * * D.23451;
  long unsigned int D.23452;
  long unsigned int D.23453;
  struct MonoClass * * D.23454;
  struct MonoClass * D.23455;
  int D.23456;
  guint16 * D.23459;
  long unsigned int D.23460;
  guint16 * D.23461;
  short unsigned int D.23462;
  short unsigned int D.23463;
  int D.23464;
  int i;

  i = mono_class_interface_offset (klass, itf);
  *non_exact_match = 0;
  if (i >= 0) goto <D.23445>; else goto <D.23446>;
  <D.23445>:
  D.23447 = i;
  return D.23447;
  <D.23446>:
  D.23448 = mono_class_has_variant_generic_params (itf);
  if (D.23448 == 0) goto <D.23449>; else goto <D.23450>;
  <D.23449>:
  D.23447 = -1;
  return D.23447;
  <D.23450>:
  i = 0;
  goto <D.19574>;
  <D.19573>:
  D.23451 = klass->interfaces_packed;
  D.23452 = (long unsigned int) i;
  D.23453 = D.23452 * 8;
  D.23454 = D.23451 + D.23453;
  D.23455 = *D.23454;
  D.23456 = mono_class_is_variant_compatible (itf, D.23455, 0);
  if (D.23456 != 0) goto <D.23457>; else goto <D.23458>;
  <D.23457>:
  *non_exact_match = 1;
  D.23459 = klass->interface_offsets_packed;
  D.23452 = (long unsigned int) i;
  D.23460 = D.23452 * 2;
  D.23461 = D.23459 + D.23460;
  D.23462 = *D.23461;
  D.23447 = (int) D.23462;
  return D.23447;
  <D.23458>:
  i = i + 1;
  <D.19574>:
  D.23463 = klass->interface_offsets_count;
  D.23464 = (int) D.23463;
  if (D.23464 > i) goto <D.19573>; else goto <D.19575>;
  <D.19575>:
  D.23447 = -1;
  return D.23447;
}


__attribute__((visibility ("hidden")))
mono_class_setup_interface_offsets (struct MonoClass * class)
{
  mono_loader_lock ();
  setup_interface_offsets (class, 0, 0);
  mono_loader_unlock ();
}


setup_interface_offsets (struct MonoClass * class, int cur_slot, gboolean overwrite)
{
  short unsigned int D.23466;
  long unsigned int D.23467;
  long unsigned int D.23468;
  struct MonoClass * * D.23469;
  long unsigned int D.23470;
  long unsigned int D.23471;
  struct MonoClass * * D.23472;
  short unsigned int D.23473;
  int D.23474;
  struct MonoClass * * D.23475;
  long unsigned int D.23476;
  long unsigned int D.23477;
  struct MonoClass * * D.23478;
  long unsigned int D.23479;
  long unsigned int D.23480;
  short unsigned int D.23483;
  int D.23484;
  int D.23487;
  const char * D.23490;
  gchar * D.23491;
  unsigned int D.23494;
  unsigned int num_ifaces.95;
  unsigned int D.23496;
  void * * D.23497;
  void * * D.23498;
  unsigned int i.96;
  struct GPtrArray * * D.23502;
  int D.23503;
  struct MonoClass * * D.23504;
  int num_array_interfaces.97;
  unsigned int D.23510;
  unsigned int D.23511;
  unsigned char D.23513;
  short unsigned int D.23515;
  int D.23516;
  short unsigned int D.23519;
  long unsigned int D.23520;
  long unsigned int D.23521;
  long unsigned int D.23522;
  long unsigned int D.23523;
  int * D.23524;
  _Bool D.23527;
  long int D.23528;
  long int D.23529;
  int D.23532;
  sizetype D.23533;
  struct MonoClass * * D.23534;
  struct MonoClass * D.23535;
  _Bool D.23536;
  long int D.23537;
  long int D.23538;
  struct GPtrArray * * D.23541;
  int D.23544;
  gchar * D.23549;
  int is_enumerator.98;
  struct MonoClass * * D.23559;
  long unsigned int D.23560;
  long unsigned int D.23561;
  struct MonoClass * * D.23562;
  struct MonoClass * D.23563;
  _Bool D.23564;
  long int D.23565;
  long int D.23566;
  const char * D.23569;
  int D.23570;
  long unsigned int D.23575;
  long unsigned int D.23576;
  struct MonoClass * * D.23577;
  struct MonoClass * iftmp.99;
  long unsigned int D.23581;
  long unsigned int D.23582;
  struct MonoClass * * D.23583;
  int iftmp.100;
  struct MonoClass * D.23589;
  struct MonoClass * * D.23590;
  long unsigned int D.23591;
  long unsigned int D.23592;
  struct MonoClass * * D.23593;
  struct MonoClass * D.23594;
  long unsigned int D.23595;
  long unsigned int D.23596;
  struct MonoClass * * D.23597;
  struct MonoClass * D.23598;
  int iftmp.101;
  struct MonoClass * D.23602;
  int iftmp.102;
  struct MonoClass * * D.23607;
  long unsigned int D.23608;
  long unsigned int D.23609;
  struct MonoClass * * D.23610;
  struct MonoClass * D.23611;
  int iftmp.103;
  _Bool D.23619;
  long int D.23620;
  long int D.23621;
  struct MonoGenericClass * D.23624;
  struct MonoClass * D.23625;
  struct MonoClass * D.23626;
  int D.23630;
  int D.23634;
  int D.23638;
  int D.23642;
  int D.23646;
  struct MonoClass * * D.23651;
  short unsigned int D.23654;
  int D.23655;
  _Bool D.23656;
  long int D.23657;
  long int D.23658;
  short unsigned int D.23661;
  unsigned int interface_offsets_count.104;
  unsigned int D.23663;
  int D.23664;
  void * D.23665;
  unsigned int D.23666;
  int D.23667;
  void * D.23668;
  int D.23669;
  int D.23670;
  unsigned int D.23671;
  unsigned int iftmp.105;
  int D.23673;
  unsigned int D.23677;
  struct MonoClass * * D.23678;
  struct MonoClass * D.23679;
  short unsigned int D.23680;
  int D.23681;
  sizetype D.23682;
  uint8_t * D.23683;
  unsigned char D.23684;
  signed char D.23685;
  int D.23686;
  int D.23687;
  signed char D.23688;
  signed char D.23689;
  unsigned char D.23690;
  struct MonoClass * * D.23691;
  guint16 * D.23692;
  long unsigned int D.23693;
  guint16 * D.23694;
  short unsigned int D.23695;
  struct GPtrArray * * D.23696;
  int D.23699;
  struct MonoError error;
  struct MonoClass * k;
  struct MonoClass * ic;
  int i;
  int j;
  int max_iid;
  int num_ifaces;
  struct MonoClass * * interfaces_full;
  int * interface_offsets_full;
  struct GPtrArray * ifaces;
  struct GPtrArray * * ifaces_array;
  int interface_offsets_count;
  struct MonoClass * * array_interfaces;
  int num_array_interfaces;
  int is_enumerator;
  void end = <<< error >>>;

  try
    {
      interfaces_full = 0B;
      interface_offsets_full = 0B;
      ifaces_array = 0B;
      array_interfaces = 0B;
      is_enumerator = 0;
      mono_class_setup_supertypes (class);
      array_interfaces = get_implicit_generic_array_interfaces (class, &num_array_interfaces, &is_enumerator);
      max_iid = 0;
      num_ifaces = num_array_interfaces;
      D.23466 = class->idepth;
      D.23467 = (long unsigned int) D.23466;
      D.23468 = D.23467 * 8;
      ifaces_array = monoeg_malloc0 (D.23468);
      j = 0;
      goto <D.19741>;
      <D.19740>:
      D.23469 = class->supertypes;
      D.23470 = (long unsigned int) j;
      D.23471 = D.23470 * 8;
      D.23472 = D.23469 + D.23471;
      k = *D.23472;
      D.23473 = k->interface_count;
      D.23474 = (int) D.23473;
      num_ifaces = D.23474 + num_ifaces;
      i = 0;
      goto <D.19733>;
      <D.19732>:
      D.23475 = k->interfaces;
      D.23476 = (long unsigned int) i;
      D.23477 = D.23476 * 8;
      D.23478 = D.23475 + D.23477;
      ic = *D.23478;
      D.23479 = BIT_FIELD_REF <*ic, 64, 256>;
      D.23480 = D.23479 & 9223372036854775808;
      if (D.23480 == 0) goto <D.23481>; else goto <D.23482>;
      <D.23481>:
      mono_class_init (ic);
      <D.23482>:
      D.23483 = ic->interface_id;
      D.23484 = (int) D.23483;
      if (D.23484 > max_iid) goto <D.23485>; else goto <D.23486>;
      <D.23485>:
      D.23483 = ic->interface_id;
      max_iid = (int) D.23483;
      <D.23486>:
      i = i + 1;
      <D.19733>:
      D.23473 = k->interface_count;
      D.23474 = (int) D.23473;
      if (D.23474 > i) goto <D.19732>; else goto <D.19734>;
      <D.19734>:
      ifaces = mono_class_get_implemented_interfaces (k, &error);
      D.23487 = mono_error_ok (&error);
      if (D.23487 == 0) goto <D.23488>; else goto <D.23489>;
      <D.23488>:
      {
        char * name;

        name = mono_type_get_full_name (k);
        D.23490 = mono_error_get_message (&error);
        D.23491 = monoeg_g_strdup_printf ("Error getting the interfaces of %s due to %s", name, D.23490);
        mono_class_set_failure (class, 7, D.23491);
        monoeg_g_free (name);
        mono_error_cleanup (&error);
        cur_slot = -1;
        goto end;
      }
      <D.23489>:
      if (ifaces != 0B) goto <D.23492>; else goto <D.23493>;
      <D.23492>:
      D.23494 = ifaces->len;
      num_ifaces.95 = (unsigned int) num_ifaces;
      D.23496 = D.23494 + num_ifaces.95;
      num_ifaces = (int) D.23496;
      i = 0;
      goto <D.19738>;
      <D.19737>:
      D.23497 = ifaces->pdata;
      D.23476 = (long unsigned int) i;
      D.23477 = D.23476 * 8;
      D.23498 = D.23497 + D.23477;
      ic = *D.23498;
      D.23483 = ic->interface_id;
      D.23484 = (int) D.23483;
      if (D.23484 > max_iid) goto <D.23499>; else goto <D.23500>;
      <D.23499>:
      D.23483 = ic->interface_id;
      max_iid = (int) D.23483;
      <D.23500>:
      i = i + 1;
      <D.19738>:
      D.23494 = ifaces->len;
      i.96 = (unsigned int) i;
      if (D.23494 > i.96) goto <D.19737>; else goto <D.19739>;
      <D.19739>:
      D.23470 = (long unsigned int) j;
      D.23471 = D.23470 * 8;
      D.23502 = ifaces_array + D.23471;
      *D.23502 = ifaces;
      <D.23493>:
      j = j + 1;
      <D.19741>:
      D.23466 = class->idepth;
      D.23503 = (int) D.23466;
      if (D.23503 > j) goto <D.19740>; else goto <D.19742>;
      <D.19742>:
      i = 0;
      goto <D.19744>;
      <D.19743>:
      D.23476 = (long unsigned int) i;
      D.23477 = D.23476 * 8;
      D.23504 = array_interfaces + D.23477;
      ic = *D.23504;
      mono_class_init (ic);
      D.23483 = ic->interface_id;
      D.23484 = (int) D.23483;
      if (D.23484 > max_iid) goto <D.23505>; else goto <D.23506>;
      <D.23505>:
      D.23483 = ic->interface_id;
      max_iid = (int) D.23483;
      <D.23506>:
      i = i + 1;
      <D.19744>:
      num_array_interfaces.97 = num_array_interfaces;
      if (i < num_array_interfaces.97) goto <D.19743>; else goto <D.19745>;
      <D.19745>:
      D.23510 = class->flags;
      D.23511 = D.23510 & 32;
      if (D.23511 != 0) goto <D.23508>; else goto <D.23512>;
      <D.23512>:
      D.23513 = class->byval_arg.type;
      if (D.23513 == 19) goto <D.23508>; else goto <D.23514>;
      <D.23514>:
      D.23513 = class->byval_arg.type;
      if (D.23513 == 30) goto <D.23508>; else goto <D.23509>;
      <D.23508>:
      num_ifaces = num_ifaces + 1;
      D.23515 = class->interface_id;
      D.23516 = (int) D.23515;
      if (D.23516 > max_iid) goto <D.23517>; else goto <D.23518>;
      <D.23517>:
      D.23515 = class->interface_id;
      max_iid = (int) D.23515;
      <D.23518>:
      <D.23509>:
      D.23519 = (short unsigned int) max_iid;
      class->max_interface_id = D.23519;
      D.23520 = (long unsigned int) num_ifaces;
      D.23521 = D.23520 * 8;
      interfaces_full = monoeg_malloc0 (D.23521);
      D.23520 = (long unsigned int) num_ifaces;
      D.23522 = D.23520 * 4;
      interface_offsets_full = monoeg_malloc (D.23522);
      i = 0;
      goto <D.19747>;
      <D.19746>:
      D.23476 = (long unsigned int) i;
      D.23523 = D.23476 * 4;
      D.23524 = interface_offsets_full + D.23523;
      *D.23524 = -1;
      i = i + 1;
      <D.19747>:
      if (i < num_ifaces) goto <D.19746>; else goto <D.19748>;
      <D.19748>:
      j = 0;
      goto <D.19754>;
      <D.19753>:
      D.23469 = class->supertypes;
      D.23470 = (long unsigned int) j;
      D.23471 = D.23470 * 8;
      D.23472 = D.23469 + D.23471;
      k = *D.23472;
      D.23470 = (long unsigned int) j;
      D.23471 = D.23470 * 8;
      D.23502 = ifaces_array + D.23471;
      ifaces = *D.23502;
      if (ifaces != 0B) goto <D.23525>; else goto <D.23526>;
      <D.23525>:
      i = 0;
      goto <D.19751>;
      <D.19750>:
      {
        int io;

        D.23497 = ifaces->pdata;
        D.23476 = (long unsigned int) i;
        D.23477 = D.23476 * 8;
        D.23498 = D.23497 + D.23477;
        ic = *D.23498;
        io = mono_class_interface_offset (k, ic);
        D.23527 = io < 0;
        D.23528 = (long int) D.23527;
        D.23529 = __builtin_expect (D.23528, 0);
        if (D.23529 != 0) goto <D.23530>; else goto <D.23531>;
        <D.23530>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "class.c", 3372, "io >= 0");
        <D.23531>:
        set_interface_and_offset (num_ifaces, interfaces_full, interface_offsets_full, ic, io, 1);
      }
      i = i + 1;
      <D.19751>:
      D.23494 = ifaces->len;
      i.96 = (unsigned int) i;
      if (D.23494 > i.96) goto <D.19750>; else goto <D.19752>;
      <D.19752>:
      <D.23526>:
      j = j + 1;
      <D.19754>:
      D.23466 = class->idepth;
      D.23503 = (int) D.23466;
      D.23532 = D.23503 + -1;
      if (D.23532 > j) goto <D.19753>; else goto <D.19755>;
      <D.19755>:
      D.23469 = class->supertypes;
      D.23466 = class->idepth;
      D.23467 = (long unsigned int) D.23466;
      D.23468 = D.23467 * 8;
      D.23533 = D.23468 + 18446744073709551608;
      D.23534 = D.23469 + D.23533;
      D.23535 = *D.23534;
      D.23536 = D.23535 != class;
      D.23537 = (long int) D.23536;
      D.23538 = __builtin_expect (D.23537, 0);
      if (D.23538 != 0) goto <D.23539>; else goto <D.23540>;
      <D.23539>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "class.c", 3378, "class == class->supertypes [class->idepth - 1]");
      <D.23540>:
      D.23466 = class->idepth;
      D.23467 = (long unsigned int) D.23466;
      D.23468 = D.23467 * 8;
      D.23533 = D.23468 + 18446744073709551608;
      D.23541 = ifaces_array + D.23533;
      ifaces = *D.23541;
      if (ifaces != 0B) goto <D.23542>; else goto <D.23543>;
      <D.23542>:
      i = 0;
      goto <D.19760>;
      <D.19759>:
      {
        int count;

        D.23497 = ifaces->pdata;
        D.23476 = (long unsigned int) i;
        D.23477 = D.23476 * 8;
        D.23498 = D.23497 + D.23477;
        ic = *D.23498;
        D.23544 = set_interface_and_offset (num_ifaces, interfaces_full, interface_offsets_full, ic, cur_slot, 0);
        if (D.23544 != 0) goto <D.23545>; else goto <D.23546>;
        <D.23545>:
        // predicted unlikely by continue predictor.
        goto <D.19757>;
        <D.23546>:
        count = count_virtual_methods (ic);
        if (count == -1) goto <D.23547>; else goto <D.23548>;
        <D.23547>:
        {
          char * name;

          name = mono_type_get_full_name (ic);
          D.23549 = monoeg_g_strdup_printf ("Error calculating interface offset of %s", name);
          mono_class_set_failure (class, 7, D.23549);
          monoeg_g_free (name);
          cur_slot = -1;
          goto end;
        }
        <D.23548>:
        cur_slot = cur_slot + count;
      }
      <D.19757>:
      i = i + 1;
      <D.19760>:
      D.23494 = ifaces->len;
      i.96 = (unsigned int) i;
      if (D.23494 > i.96) goto <D.19759>; else goto <D.19761>;
      <D.19761>:
      <D.23543>:
      D.23510 = class->flags;
      D.23511 = D.23510 & 32;
      if (D.23511 != 0) goto <D.23550>; else goto <D.23552>;
      <D.23552>:
      D.23513 = class->byval_arg.type;
      if (D.23513 == 19) goto <D.23550>; else goto <D.23553>;
      <D.23553>:
      D.23513 = class->byval_arg.type;
      if (D.23513 == 30) goto <D.23550>; else goto <D.23551>;
      <D.23550>:
      set_interface_and_offset (num_ifaces, interfaces_full, interface_offsets_full, class, cur_slot, 1);
      <D.23551>:
      num_array_interfaces.97 = num_array_interfaces;
      if (num_array_interfaces.97 != 0) goto <D.23554>; else goto <D.23555>;
      <D.23554>:
      is_enumerator.98 = is_enumerator;
      if (is_enumerator.98 != 0) goto <D.23557>; else goto <D.23558>;
      <D.23557>:
      {
        int ienumerator_idx;
        int ienumerator_offset;

        ienumerator_idx = find_array_interface (class, "IEnumerator`1");
        D.23559 = class->interfaces;
        D.23560 = (long unsigned int) ienumerator_idx;
        D.23561 = D.23560 * 8;
        D.23562 = D.23559 + D.23561;
        D.23563 = *D.23562;
        ienumerator_offset = find_interface_offset (num_ifaces, interfaces_full, interface_offsets_full, D.23563);
        D.23564 = ienumerator_offset < 0;
        D.23565 = (long int) D.23564;
        D.23566 = __builtin_expect (D.23565, 0);
        if (D.23566 != 0) goto <D.23567>; else goto <D.23568>;
        <D.23567>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "class.c", 3405, "ienumerator_offset >= 0");
        <D.23568>:
        i = 0;
        goto <D.19765>;
        <D.19764>:
        D.23476 = (long unsigned int) i;
        D.23477 = D.23476 * 8;
        D.23504 = array_interfaces + D.23477;
        ic = *D.23504;
        D.23569 = ic->name;
        D.23570 = strcmp (D.23569, "IEnumerator`1");
        if (D.23570 == 0) goto <D.23571>; else goto <D.23572>;
        <D.23571>:
        set_interface_and_offset (num_ifaces, interfaces_full, interface_offsets_full, ic, ienumerator_offset, 1);
        goto <D.23573>;
        <D.23572>:
        monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "class.c", 3411);
        <D.23573>:
        i = i + 1;
        <D.19765>:
        num_array_interfaces.97 = num_array_interfaces;
        if (i < num_array_interfaces.97) goto <D.19764>; else goto <D.19766>;
        <D.19766>:
      }
      goto <D.23574>;
      <D.23558>:
      {
        int ilist_offset;
        int icollection_offset;
        int ienumerable_offset;
        int ireadonlylist_offset;
        int ireadonlycollection_offset;
        int ilist_iface_idx;
        struct MonoClass * ilist_class;
        int ireadonlylist_iface_idx;
        struct MonoClass * ireadonlylist_class;
        int icollection_iface_idx;
        int ienumerable_iface_idx;
        int ireadonlycollection_iface_idx;

        ilist_iface_idx = find_array_interface (class, "IList`1");
        D.23559 = class->interfaces;
        D.23575 = (long unsigned int) ilist_iface_idx;
        D.23576 = D.23575 * 8;
        D.23577 = D.23559 + D.23576;
        ilist_class = *D.23577;
        ireadonlylist_iface_idx = find_array_interface (class, "IReadOnlyList`1");
        if (ireadonlylist_iface_idx != -1) goto <D.23579>; else goto <D.23580>;
        <D.23579>:
        D.23559 = class->interfaces;
        D.23581 = (long unsigned int) ireadonlylist_iface_idx;
        D.23582 = D.23581 * 8;
        D.23583 = D.23559 + D.23582;
        iftmp.99 = *D.23583;
        goto <D.23584>;
        <D.23580>:
        iftmp.99 = 0B;
        <D.23584>:
        ireadonlylist_class = iftmp.99;
        icollection_iface_idx = find_array_interface (ilist_class, "ICollection`1");
        ienumerable_iface_idx = find_array_interface (ilist_class, "IEnumerable`1");
        if (ireadonlylist_iface_idx != -1) goto <D.23586>; else goto <D.23587>;
        <D.23586>:
        iftmp.100 = find_array_interface (ireadonlylist_class, "IReadOnlyCollection`1");
        goto <D.23588>;
        <D.23587>:
        iftmp.100 = -1;
        <D.23588>:
        ireadonlycollection_iface_idx = iftmp.100;
        D.23559 = class->interfaces;
        D.23575 = (long unsigned int) ilist_iface_idx;
        D.23576 = D.23575 * 8;
        D.23577 = D.23559 + D.23576;
        D.23589 = *D.23577;
        ilist_offset = find_interface_offset (num_ifaces, interfaces_full, interface_offsets_full, D.23589);
        D.23590 = ilist_class->interfaces;
        D.23591 = (long unsigned int) icollection_iface_idx;
        D.23592 = D.23591 * 8;
        D.23593 = D.23590 + D.23592;
        D.23594 = *D.23593;
        icollection_offset = find_interface_offset (num_ifaces, interfaces_full, interface_offsets_full, D.23594);
        D.23590 = ilist_class->interfaces;
        D.23595 = (long unsigned int) ienumerable_iface_idx;
        D.23596 = D.23595 * 8;
        D.23597 = D.23590 + D.23596;
        D.23598 = *D.23597;
        ienumerable_offset = find_interface_offset (num_ifaces, interfaces_full, interface_offsets_full, D.23598);
        if (ireadonlylist_iface_idx != -1) goto <D.23600>; else goto <D.23601>;
        <D.23600>:
        D.23559 = class->interfaces;
        D.23581 = (long unsigned int) ireadonlylist_iface_idx;
        D.23582 = D.23581 * 8;
        D.23583 = D.23559 + D.23582;
        D.23602 = *D.23583;
        iftmp.101 = find_interface_offset (num_ifaces, interfaces_full, interface_offsets_full, D.23602);
        goto <D.23603>;
        <D.23601>:
        iftmp.101 = -1;
        <D.23603>:
        ireadonlylist_offset = iftmp.101;
        if (ireadonlycollection_iface_idx != -1) goto <D.23605>; else goto <D.23606>;
        <D.23605>:
        D.23607 = ireadonlylist_class->interfaces;
        D.23608 = (long unsigned int) ireadonlycollection_iface_idx;
        D.23609 = D.23608 * 8;
        D.23610 = D.23607 + D.23609;
        D.23611 = *D.23610;
        iftmp.102 = find_interface_offset (num_ifaces, interfaces_full, interface_offsets_full, D.23611);
        goto <D.23612>;
        <D.23606>:
        iftmp.102 = -1;
        <D.23612>:
        ireadonlycollection_offset = iftmp.102;
        if (ilist_offset < 0) goto <D.23614>; else goto <D.23617>;
        <D.23617>:
        if (icollection_offset < 0) goto <D.23614>; else goto <D.23618>;
        <D.23618>:
        if (ienumerable_offset < 0) goto <D.23614>; else goto <D.23615>;
        <D.23614>:
        iftmp.103 = 1;
        goto <D.23616>;
        <D.23615>:
        iftmp.103 = 0;
        <D.23616>:
        D.23619 = iftmp.103 != 0;
        D.23620 = (long int) D.23619;
        D.23621 = __builtin_expect (D.23620, 0);
        if (D.23621 != 0) goto <D.23622>; else goto <D.23623>;
        <D.23622>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "class.c", 3428, "ilist_offset >= 0 && icollection_offset >= 0 && ienumerable_offset >= 0");
        <D.23623>:
        i = 0;
        goto <D.19781>;
        <D.19780>:
        {
          int offset;

          D.23476 = (long unsigned int) i;
          D.23477 = D.23476 * 8;
          D.23504 = array_interfaces + D.23477;
          ic = *D.23504;
          D.23624 = ic->generic_class;
          D.23625 = D.23624->container_class;
          D.23626 = mono_defaults.generic_ilist_class;
          if (D.23625 == D.23626) goto <D.23627>; else goto <D.23628>;
          <D.23627>:
          offset = ilist_offset;
          goto <D.23629>;
          <D.23628>:
          D.23569 = ic->name;
          D.23630 = strcmp (D.23569, "ICollection`1");
          if (D.23630 == 0) goto <D.23631>; else goto <D.23632>;
          <D.23631>:
          offset = icollection_offset;
          goto <D.23633>;
          <D.23632>:
          D.23569 = ic->name;
          D.23634 = strcmp (D.23569, "IEnumerable`1");
          if (D.23634 == 0) goto <D.23635>; else goto <D.23636>;
          <D.23635>:
          offset = ienumerable_offset;
          goto <D.23637>;
          <D.23636>:
          D.23569 = ic->name;
          D.23638 = strcmp (D.23569, "IReadOnlyList`1");
          if (D.23638 == 0) goto <D.23639>; else goto <D.23640>;
          <D.23639>:
          offset = ireadonlylist_offset;
          goto <D.23641>;
          <D.23640>:
          D.23569 = ic->name;
          D.23642 = strcmp (D.23569, "IReadOnlyCollection`1");
          if (D.23642 == 0) goto <D.23643>; else goto <D.23644>;
          <D.23643>:
          offset = ireadonlycollection_offset;
          goto <D.23645>;
          <D.23644>:
          monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "class.c", 3443);
          <D.23645>:
          <D.23641>:
          <D.23637>:
          <D.23633>:
          <D.23629>:
          set_interface_and_offset (num_ifaces, interfaces_full, interface_offsets_full, ic, offset, 1);
        }
        i = i + 1;
        <D.19781>:
        num_array_interfaces.97 = num_array_interfaces;
        if (i < num_array_interfaces.97) goto <D.19780>; else goto <D.19782>;
        <D.19782>:
      }
      <D.23574>:
      <D.23555>:
      interface_offsets_count = 0;
      i = 0;
      goto <D.19784>;
      <D.19783>:
      D.23476 = (long unsigned int) i;
      D.23523 = D.23476 * 4;
      D.23524 = interface_offsets_full + D.23523;
      D.23646 = *D.23524;
      if (D.23646 != -1) goto <D.23647>; else goto <D.23648>;
      <D.23647>:
      interface_offsets_count = interface_offsets_count + 1;
      <D.23648>:
      i = i + 1;
      <D.19784>:
      if (i < num_ifaces) goto <D.19783>; else goto <D.19785>;
      <D.19785>:
      D.23651 = class->interfaces_packed;
      if (D.23651 != 0B) goto <D.23652>; else goto <D.23649>;
      <D.23652>:
      if (overwrite == 0) goto <D.23653>; else goto <D.23649>;
      <D.23653>:
      D.23654 = class->interface_offsets_count;
      D.23655 = (int) D.23654;
      D.23656 = D.23655 != interface_offsets_count;
      D.23657 = (long int) D.23656;
      D.23658 = __builtin_expect (D.23657, 0);
      if (D.23658 != 0) goto <D.23659>; else goto <D.23660>;
      <D.23659>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "class.c", 3465, "class->interface_offsets_count == interface_offsets_count");
      <D.23660>:
      goto <D.23650>;
      <D.23649>:
      {
        uint8_t * bitmap;
        int bsize;

        D.23661 = (short unsigned int) interface_offsets_count;
        class->interface_offsets_count = D.23661;
        interface_offsets_count.104 = (unsigned int) interface_offsets_count;
        D.23663 = interface_offsets_count.104 * 8;
        D.23664 = (int) D.23663;
        D.23665 = mono_class_alloc (class, D.23664);
        class->interfaces_packed = D.23665;
        interface_offsets_count.104 = (unsigned int) interface_offsets_count;
        D.23666 = interface_offsets_count.104 * 2;
        D.23667 = (int) D.23666;
        D.23668 = mono_class_alloc (class, D.23667);
        class->interface_offsets_packed = D.23668;
        D.23669 = max_iid + 1;
        D.23670 = D.23669 >> 3;
        D.23671 = (unsigned int) D.23670;
        D.23669 = max_iid + 1;
        D.23673 = D.23669 & 7;
        if (D.23673 != 0) goto <D.23674>; else goto <D.23675>;
        <D.23674>:
        iftmp.105 = 1;
        goto <D.23676>;
        <D.23675>:
        iftmp.105 = 0;
        <D.23676>:
        D.23677 = D.23671 + iftmp.105;
        bsize = (int) D.23677;
        bitmap = mono_class_alloc0 (class, bsize);
        i = 0;
        goto <D.19790>;
        <D.19789>:
        {
          int id;

          D.23476 = (long unsigned int) i;
          D.23477 = D.23476 * 8;
          D.23678 = interfaces_full + D.23477;
          D.23679 = *D.23678;
          D.23680 = D.23679->interface_id;
          id = (int) D.23680;
          D.23681 = id >> 3;
          D.23682 = (sizetype) D.23681;
          D.23683 = bitmap + D.23682;
          D.23681 = id >> 3;
          D.23682 = (sizetype) D.23681;
          D.23683 = bitmap + D.23682;
          D.23684 = *D.23683;
          D.23685 = (signed char) D.23684;
          D.23686 = id & 7;
          D.23687 = 1 << D.23686;
          D.23688 = (signed char) D.23687;
          D.23689 = D.23685 | D.23688;
          D.23690 = (unsigned char) D.23689;
          *D.23683 = D.23690;
          D.23651 = class->interfaces_packed;
          D.23476 = (long unsigned int) i;
          D.23477 = D.23476 * 8;
          D.23691 = D.23651 + D.23477;
          D.23476 = (long unsigned int) i;
          D.23477 = D.23476 * 8;
          D.23678 = interfaces_full + D.23477;
          D.23679 = *D.23678;
          *D.23691 = D.23679;
          D.23692 = class->interface_offsets_packed;
          D.23476 = (long unsigned int) i;
          D.23693 = D.23476 * 2;
          D.23694 = D.23692 + D.23693;
          D.23476 = (long unsigned int) i;
          D.23523 = D.23476 * 4;
          D.23524 = interface_offsets_full + D.23523;
          D.23646 = *D.23524;
          D.23695 = (short unsigned int) D.23646;
          *D.23694 = D.23695;
        }
        i = i + 1;
        <D.19790>:
        if (i < interface_offsets_count) goto <D.19789>; else goto <D.19791>;
        <D.19791>:
        class->interface_bitmap = bitmap;
      }
      <D.23650>:
      end:
      monoeg_g_free (interfaces_full);
      monoeg_g_free (interface_offsets_full);
      monoeg_g_free (array_interfaces);
      i = 0;
      goto <D.19793>;
      <D.19792>:
      D.23476 = (long unsigned int) i;
      D.23477 = D.23476 * 8;
      D.23696 = ifaces_array + D.23477;
      ifaces = *D.23696;
      if (ifaces != 0B) goto <D.23697>; else goto <D.23698>;
      <D.23697>:
      monoeg_g_ptr_array_free (ifaces, 1);
      <D.23698>:
      i = i + 1;
      <D.19793>:
      D.23466 = class->idepth;
      D.23503 = (int) D.23466;
      if (D.23503 > i) goto <D.19792>; else goto <D.19794>;
      <D.19794>:
      monoeg_g_free (ifaces_array);
      D.23699 = cur_slot;
      return D.23699;
    }
  finally
    {
      error = {CLOBBER};
      num_array_interfaces = {CLOBBER};
      is_enumerator = {CLOBBER};
    }
}


get_implicit_generic_array_interfaces (struct MonoClass * class, int * num, int * is_enumerator)
{
  struct MonoClass * D.23702;
  struct MonoClass * * D.23705;
  unsigned char D.23706;
  unsigned char D.23707;
  struct MonoGenericClass * D.23712;
  struct MonoClass * D.23714;
  struct MonoClass * D.23715;
  const char * D.23717;
  int D.23718;
  struct MonoGenericInst * D.23720;
  struct MonoType * D.23721;
  int iftmp.106;
  struct MonoClass * D.23729;
  unsigned char D.23730;
  struct MonoClass * generic_icollection_class.107;
  struct MonoImage * D.23734;
  struct MonoClass * generic_icollection_class.108;
  struct MonoClass * generic_ienumerable_class.109;
  struct MonoClass * generic_ienumerator_class.110;
  struct MonoClass * generic_ireadonlylist_class.111;
  struct MonoClass * generic_ireadonlycollection_class.112;
  long unsigned int D.23740;
  long unsigned int D.23741;
  int iftmp.113;
  struct MonoClass * generic_ireadonlylist_class.114;
  int iftmp.115;
  struct MonoClass * D.23750;
  long unsigned int D.23758;
  long unsigned int D.23759;
  struct MonoClass * D.23760;
  long unsigned int D.23763;
  long unsigned int D.23764;
  struct MonoClass * * D.23765;
  short unsigned int D.23767;
  int iftmp.116;
  unsigned char D.23776;
  struct MonoImage * D.23781;
  long unsigned int D.23782;
  long unsigned int D.23783;
  long unsigned int D.23785;
  int iftmp.117;
  short unsigned int D.23789;
  short unsigned int D.23791;
  unsigned int D.23795;
  unsigned int D.23796;
  unsigned char D.23798;
  long unsigned int D.23802;
  long unsigned int D.23803;
  int iftmp.118;
  int D.23816;
  int D.23817;
  struct MonoClass * D.23824;
  struct MonoClass * * D.23825;
  long unsigned int D.23826;
  long unsigned int D.23827;
  struct MonoClass * * D.23828;
  struct MonoClass * D.23829;
  long unsigned int D.23830;
  long unsigned int D.23831;
  struct MonoClass * * D.23832;
  struct MonoClass * * D.23835;
  struct MonoClass * * D.23836;
  struct MonoClass * D.23837;
  struct MonoClass * * D.23839;
  struct MonoClass * * D.23840;
  struct MonoClass * D.23841;
  int D.23842;
  unsigned int original_rank.119;
  struct MonoClass * D.23846;
  struct MonoClass * * D.23847;
  struct MonoClass * D.23848;
  sizetype D.23849;
  sizetype D.23850;
  sizetype D.23851;
  struct MonoClass * * D.23852;
  struct MonoClass * D.23853;
  sizetype D.23856;
  sizetype D.23857;
  struct MonoClass * * D.23858;
  struct MonoClass * generic_ienumerable_class.120;
  struct MonoClass * D.23860;
  sizetype D.23863;
  sizetype D.23864;
  struct MonoClass * * D.23865;
  struct MonoClass * D.23866;
  sizetype D.23867;
  sizetype D.23868;
  struct MonoClass * * D.23869;
  struct MonoClass * generic_ireadonlycollection_class.121;
  struct MonoClass * D.23871;
  struct MonoClass * D.23875;
  struct MonoClass * generic_ienumerator_class.122;
  struct MonoClass * D.23879;
  struct MonoClass * D.23880;
  long unsigned int D.23887;
  long unsigned int D.23888;
  struct MonoClass * * D.23889;
  struct MonoClass * D.23890;
  struct MonoClass * D.23891;
  int D.23892;
  struct MonoClass * D.23893;
  int j.123;
  long unsigned int D.23896;
  long unsigned int D.23897;
  struct MonoClass * * D.23898;
  struct MonoClass * D.23899;
  struct MonoClass * D.23900;
  struct MonoClass * D.23903;
  struct MonoClass * D.23904;
  struct MonoClass * eclass;
  static struct MonoClass * generic_icollection_class = 0B;
  static struct MonoClass * generic_ienumerable_class = 0B;
  static struct MonoClass * generic_ienumerator_class = 0B;
  static struct MonoClass * generic_ireadonlylist_class = 0B;
  static struct MonoClass * generic_ireadonlycollection_class = 0B;
  struct MonoClass * valuetype_types[2];
  struct MonoClass * * interfaces;
  int i;
  int nifaces;
  int interface_count;
  int real_count;
  int original_rank;
  int all_interfaces;
  gboolean internal_enumerator;
  gboolean eclass_is_valuetype;

  try
    {
      eclass = class->element_class;
      valuetype_types[0] = 0B;
      valuetype_types[1] = 0B;
      interfaces = 0B;
      D.23702 = mono_defaults.generic_ilist_class;
      if (D.23702 == 0B) goto <D.23703>; else goto <D.23704>;
      <D.23703>:
      *num = 0;
      D.23705 = 0B;
      return D.23705;
      <D.23704>:
      internal_enumerator = 0;
      eclass_is_valuetype = 0;
      D.23706 = eclass->rank;
      original_rank = (int) D.23706;
      D.23707 = class->byval_arg.type;
      if (D.23707 != 29) goto <D.23708>; else goto <D.23709>;
      <D.23708>:
      D.23712 = class->generic_class;
      if (D.23712 != 0B) goto <D.23713>; else goto <D.23710>;
      <D.23713>:
      D.23714 = class->nested_in;
      D.23715 = mono_defaults.array_class;
      if (D.23714 == D.23715) goto <D.23716>; else goto <D.23710>;
      <D.23716>:
      D.23717 = class->name;
      D.23718 = strcmp (D.23717, "InternalEnumerator`1");
      if (D.23718 == 0) goto <D.23719>; else goto <D.23710>;
      <D.23719>:
      D.23712 = class->generic_class;
      D.23720 = D.23712->context.class_inst;
      D.23721 = D.23720->type_argv[0];
      eclass = mono_class_from_mono_type (D.23721);
      D.23706 = eclass->rank;
      original_rank = (int) D.23706;
      D.23706 = eclass->rank;
      if (D.23706 == 0) goto <D.23722>; else goto <D.23723>;
      <D.23722>:
      eclass = eclass->element_class;
      <D.23723>:
      internal_enumerator = 1;
      *is_enumerator = 1;
      goto <D.23711>;
      <D.23710>:
      *num = 0;
      D.23705 = 0B;
      return D.23705;
      <D.23711>:
      <D.23709>:
      D.23706 = eclass->rank;
      if (D.23706 == 0) goto <D.23725>; else goto <D.23728>;
      <D.23728>:
      D.23729 = eclass->element_class;
      D.23730 = D.23729->rank;
      if (D.23730 == 0) goto <D.23725>; else goto <D.23726>;
      <D.23725>:
      iftmp.106 = 1;
      goto <D.23727>;
      <D.23726>:
      iftmp.106 = 0;
      <D.23727>:
      all_interfaces = iftmp.106;
      generic_icollection_class.107 = generic_icollection_class;
      if (generic_icollection_class.107 == 0B) goto <D.23732>; else goto <D.23733>;
      <D.23732>:
      D.23734 = mono_defaults.corlib;
      generic_icollection_class.108 = mono_class_from_name (D.23734, "System.Collections.Generic", "ICollection`1");
      generic_icollection_class = generic_icollection_class.108;
      D.23734 = mono_defaults.corlib;
      generic_ienumerable_class.109 = mono_class_from_name (D.23734, "System.Collections.Generic", "IEnumerable`1");
      generic_ienumerable_class = generic_ienumerable_class.109;
      D.23734 = mono_defaults.corlib;
      generic_ienumerator_class.110 = mono_class_from_name (D.23734, "System.Collections.Generic", "IEnumerator`1");
      generic_ienumerator_class = generic_ienumerator_class.110;
      D.23734 = mono_defaults.corlib;
      generic_ireadonlylist_class.111 = mono_class_from_name (D.23734, "System.Collections.Generic", "IReadOnlyList`1");
      generic_ireadonlylist_class = generic_ireadonlylist_class.111;
      D.23734 = mono_defaults.corlib;
      generic_ireadonlycollection_class.112 = mono_class_from_name (D.23734, "System.Collections.Generic", "IReadOnlyCollection`1");
      generic_ireadonlycollection_class = generic_ireadonlycollection_class.112;
      <D.23733>:
      mono_class_init (eclass);
      D.23740 = BIT_FIELD_REF <*eclass, 64, 256>;
      D.23741 = D.23740 & 1152921504606846976;
      if (D.23741 != 0) goto <D.23742>; else goto <D.23743>;
      <D.23742>:
      generic_ireadonlylist_class.114 = generic_ireadonlylist_class;
      if (generic_ireadonlylist_class.114 != 0B) goto <D.23746>; else goto <D.23747>;
      <D.23746>:
      iftmp.113 = 5;
      goto <D.23748>;
      <D.23747>:
      iftmp.113 = 3;
      <D.23748>:
      nifaces = iftmp.113;
      fill_valuetype_array_derived_types (&valuetype_types, eclass, original_rank);
      D.23750 = valuetype_types[1];
      if (D.23750 != 0B) goto <D.23751>; else goto <D.23752>;
      <D.23751>:
      iftmp.115 = nifaces * 2;
      goto <D.23753>;
      <D.23752>:
      iftmp.115 = nifaces;
      <D.23753>:
      interface_count = iftmp.115;
      real_count = interface_count;
      if (internal_enumerator != 0) goto <D.23754>; else goto <D.23755>;
      <D.23754>:
      real_count = real_count + 1;
      D.23750 = valuetype_types[1];
      if (D.23750 != 0B) goto <D.23756>; else goto <D.23757>;
      <D.23756>:
      real_count = real_count + 1;
      <D.23757>:
      <D.23755>:
      D.23758 = (long unsigned int) real_count;
      D.23759 = D.23758 * 8;
      interfaces = monoeg_malloc0 (D.23759);
      D.23760 = valuetype_types[0];
      *interfaces = D.23760;
      D.23750 = valuetype_types[1];
      if (D.23750 != 0B) goto <D.23761>; else goto <D.23762>;
      <D.23761>:
      D.23763 = (long unsigned int) nifaces;
      D.23764 = D.23763 * 8;
      D.23765 = interfaces + D.23764;
      D.23750 = valuetype_types[1];
      *D.23765 = D.23750;
      <D.23762>:
      eclass_is_valuetype = 1;
      goto <D.23766>;
      <D.23743>:
      {
        int j;
        int idepth;

        D.23767 = eclass->idepth;
        idepth = (int) D.23767;
        if (internal_enumerator == 0) goto <D.23768>; else goto <D.23769>;
        <D.23768>:
        idepth = idepth + -1;
        <D.23769>:
        generic_ireadonlylist_class.114 = generic_ireadonlylist_class;
        if (generic_ireadonlylist_class.114 != 0B) goto <D.23771>; else goto <D.23772>;
        <D.23771>:
        iftmp.116 = 2;
        goto <D.23773>;
        <D.23772>:
        iftmp.116 = 3;
        <D.23773>:
        nifaces = iftmp.116;
        D.23776 = eclass->this_arg.type;
        if (D.23776 != 19) goto <D.23777>; else goto <D.23778>;
        <D.23777>:
        D.23776 = eclass->this_arg.type;
        if (D.23776 != 30) goto <D.23779>; else goto <D.23780>;
        <D.23779>:
        D.23781 = eclass->image;
        D.23782 = BIT_FIELD_REF <*D.23781, 64, 192>;
        D.23783 = D.23782 & 268435456;
        if (D.23783 == 0) goto <D.23774>; else goto <D.23784>;
        <D.23784>:
        D.23740 = BIT_FIELD_REF <*eclass, 64, 256>;
        D.23785 = D.23740 & 72057594037927936;
        if (D.23785 != 0) goto <D.23774>; else goto <D.23775>;
        <D.23774>:
        mono_class_setup_interface_offsets (eclass);
        <D.23775>:
        <D.23780>:
        <D.23778>:
        if (all_interfaces != 0) goto <D.23787>; else goto <D.23788>;
        <D.23787>:
        D.23789 = eclass->interface_offsets_count;
        iftmp.117 = (int) D.23789;
        goto <D.23790>;
        <D.23788>:
        D.23791 = eclass->interface_count;
        iftmp.117 = (int) D.23791;
        <D.23790>:
        interface_count = iftmp.117;
        D.23795 = eclass->flags;
        D.23796 = D.23795 & 32;
        if (D.23796 != 0) goto <D.23792>; else goto <D.23797>;
        <D.23797>:
        D.23798 = eclass->byval_arg.type;
        if (D.23798 == 19) goto <D.23792>; else goto <D.23799>;
        <D.23799>:
        D.23798 = eclass->byval_arg.type;
        if (D.23798 == 30) goto <D.23792>; else goto <D.23793>;
        <D.23792>:
        interface_count = interface_count + 1;
        goto <D.23794>;
        <D.23793>:
        interface_count = interface_count + idepth;
        <D.23794>:
        D.23706 = eclass->rank;
        if (D.23706 != 0) goto <D.23800>; else goto <D.23801>;
        <D.23800>:
        D.23729 = eclass->element_class;
        D.23802 = BIT_FIELD_REF <*D.23729, 64, 256>;
        D.23803 = D.23802 & 1152921504606846976;
        if (D.23803 != 0) goto <D.23804>; else goto <D.23805>;
        <D.23804>:
        D.23729 = eclass->element_class;
        fill_valuetype_array_derived_types (&valuetype_types, D.23729, original_rank);
        D.23750 = valuetype_types[1];
        if (D.23750 != 0B) goto <D.23806>; else goto <D.23807>;
        <D.23806>:
        interface_count = interface_count + 1;
        <D.23807>:
        <D.23805>:
        <D.23801>:
        interface_count = interface_count * nifaces;
        real_count = interface_count;
        if (internal_enumerator != 0) goto <D.23808>; else goto <D.23809>;
        <D.23808>:
        D.23795 = eclass->flags;
        D.23796 = D.23795 & 32;
        if (D.23796 == 0) goto <D.23813>; else goto <D.23811>;
        <D.23813>:
        D.23798 = eclass->byval_arg.type;
        if (D.23798 != 19) goto <D.23814>; else goto <D.23811>;
        <D.23814>:
        D.23798 = eclass->byval_arg.type;
        if (D.23798 != 30) goto <D.23815>; else goto <D.23811>;
        <D.23815>:
        iftmp.118 = idepth;
        goto <D.23812>;
        <D.23811>:
        iftmp.118 = 1;
        <D.23812>:
        D.23789 = eclass->interface_offsets_count;
        D.23816 = (int) D.23789;
        D.23817 = iftmp.118 + D.23816;
        real_count = D.23817 + real_count;
        D.23750 = valuetype_types[1];
        if (D.23750 != 0B) goto <D.23818>; else goto <D.23819>;
        <D.23818>:
        real_count = real_count + 1;
        <D.23819>:
        <D.23809>:
        D.23758 = (long unsigned int) real_count;
        D.23759 = D.23758 * 8;
        interfaces = monoeg_malloc0 (D.23759);
        D.23795 = eclass->flags;
        D.23796 = D.23795 & 32;
        if (D.23796 != 0) goto <D.23820>; else goto <D.23822>;
        <D.23822>:
        D.23798 = eclass->byval_arg.type;
        if (D.23798 == 19) goto <D.23820>; else goto <D.23823>;
        <D.23823>:
        D.23798 = eclass->byval_arg.type;
        if (D.23798 == 30) goto <D.23820>; else goto <D.23821>;
        <D.23820>:
        D.23824 = mono_defaults.object_class;
        *interfaces = D.23824;
        j = nifaces;
        goto <D.19639>;
        <D.23821>:
        j = 0;
        i = 0;
        goto <D.19638>;
        <D.19637>:
        D.23825 = eclass->supertypes;
        D.23826 = (long unsigned int) i;
        D.23827 = D.23826 * 8;
        D.23828 = D.23825 + D.23827;
        D.23829 = *D.23828;
        mono_class_init (D.23829);
        D.23830 = (long unsigned int) j;
        D.23831 = D.23830 * 8;
        D.23832 = interfaces + D.23831;
        D.23825 = eclass->supertypes;
        D.23826 = (long unsigned int) i;
        D.23827 = D.23826 * 8;
        D.23828 = D.23825 + D.23827;
        D.23829 = *D.23828;
        *D.23832 = D.23829;
        j = j + nifaces;
        i = i + 1;
        <D.19638>:
        if (i < idepth) goto <D.19637>; else goto <D.19639>;
        <D.19639>:
        if (all_interfaces != 0) goto <D.23833>; else goto <D.23834>;
        <D.23833>:
        i = 0;
        goto <D.19641>;
        <D.19640>:
        D.23830 = (long unsigned int) j;
        D.23831 = D.23830 * 8;
        D.23832 = interfaces + D.23831;
        D.23835 = eclass->interfaces_packed;
        D.23826 = (long unsigned int) i;
        D.23827 = D.23826 * 8;
        D.23836 = D.23835 + D.23827;
        D.23837 = *D.23836;
        *D.23832 = D.23837;
        j = j + nifaces;
        i = i + 1;
        <D.19641>:
        D.23789 = eclass->interface_offsets_count;
        D.23816 = (int) D.23789;
        if (D.23816 > i) goto <D.19640>; else goto <D.19642>;
        <D.19642>:
        goto <D.23838>;
        <D.23834>:
        i = 0;
        goto <D.19644>;
        <D.19643>:
        D.23830 = (long unsigned int) j;
        D.23831 = D.23830 * 8;
        D.23832 = interfaces + D.23831;
        D.23839 = eclass->interfaces;
        D.23826 = (long unsigned int) i;
        D.23827 = D.23826 * 8;
        D.23840 = D.23839 + D.23827;
        D.23841 = *D.23840;
        *D.23832 = D.23841;
        j = j + nifaces;
        i = i + 1;
        <D.19644>:
        D.23791 = eclass->interface_count;
        D.23842 = (int) D.23791;
        if (D.23842 > i) goto <D.19643>; else goto <D.19645>;
        <D.19645>:
        <D.23838>:
        D.23750 = valuetype_types[1];
        if (D.23750 != 0B) goto <D.23843>; else goto <D.23844>;
        <D.23843>:
        D.23830 = (long unsigned int) j;
        D.23831 = D.23830 * 8;
        D.23832 = interfaces + D.23831;
        D.23750 = valuetype_types[1];
        original_rank.119 = (unsigned int) original_rank;
        D.23846 = array_class_get_if_rank (D.23750, original_rank.119);
        *D.23832 = D.23846;
        j = j + nifaces;
        <D.23844>:
      }
      <D.23766>:
      i = 0;
      goto <D.19648>;
      <D.19647>:
      {
        struct MonoClass * iface;

        D.23826 = (long unsigned int) i;
        D.23827 = D.23826 * 8;
        D.23847 = interfaces + D.23827;
        iface = *D.23847;
        D.23826 = (long unsigned int) i;
        D.23827 = D.23826 * 8;
        D.23847 = interfaces + D.23827;
        D.23702 = mono_defaults.generic_ilist_class;
        D.23848 = inflate_class_one_arg (D.23702, iface);
        *D.23847 = D.23848;
        D.23849 = (sizetype) i;
        D.23850 = D.23849 + 1;
        D.23851 = D.23850 * 8;
        D.23852 = interfaces + D.23851;
        generic_icollection_class.107 = generic_icollection_class;
        D.23853 = inflate_class_one_arg (generic_icollection_class.107, iface);
        *D.23852 = D.23853;
        D.23740 = BIT_FIELD_REF <*eclass, 64, 256>;
        D.23741 = D.23740 & 1152921504606846976;
        if (D.23741 != 0) goto <D.23854>; else goto <D.23855>;
        <D.23854>:
        D.23849 = (sizetype) i;
        D.23856 = D.23849 + 2;
        D.23857 = D.23856 * 8;
        D.23858 = interfaces + D.23857;
        generic_ienumerable_class.120 = generic_ienumerable_class;
        D.23860 = inflate_class_one_arg (generic_ienumerable_class.120, iface);
        *D.23858 = D.23860;
        generic_ireadonlylist_class.114 = generic_ireadonlylist_class;
        if (generic_ireadonlylist_class.114 != 0B) goto <D.23861>; else goto <D.23862>;
        <D.23861>:
        D.23849 = (sizetype) i;
        D.23863 = D.23849 + 3;
        D.23864 = D.23863 * 8;
        D.23865 = interfaces + D.23864;
        generic_ireadonlylist_class.114 = generic_ireadonlylist_class;
        D.23866 = inflate_class_one_arg (generic_ireadonlylist_class.114, iface);
        *D.23865 = D.23866;
        D.23849 = (sizetype) i;
        D.23867 = D.23849 + 4;
        D.23868 = D.23867 * 8;
        D.23869 = interfaces + D.23868;
        generic_ireadonlycollection_class.121 = generic_ireadonlycollection_class;
        D.23871 = inflate_class_one_arg (generic_ireadonlycollection_class.121, iface);
        *D.23869 = D.23871;
        <D.23862>:
        goto <D.23872>;
        <D.23855>:
        generic_ireadonlylist_class.114 = generic_ireadonlylist_class;
        if (generic_ireadonlylist_class.114 == 0B) goto <D.23873>; else goto <D.23874>;
        <D.23873>:
        D.23849 = (sizetype) i;
        D.23856 = D.23849 + 2;
        D.23857 = D.23856 * 8;
        D.23858 = interfaces + D.23857;
        generic_ienumerable_class.120 = generic_ienumerable_class;
        D.23875 = inflate_class_one_arg (generic_ienumerable_class.120, iface);
        *D.23858 = D.23875;
        <D.23874>:
        <D.23872>:
      }
      i = i + nifaces;
      <D.19648>:
      if (i < interface_count) goto <D.19647>; else goto <D.19649>;
      <D.19649>:
      if (internal_enumerator != 0) goto <D.23876>; else goto <D.23877>;
      <D.23876>:
      {
        int j;

        i = 0;
        goto <D.19652>;
        <D.19651>:
        D.23826 = (long unsigned int) i;
        D.23827 = D.23826 * 8;
        D.23847 = interfaces + D.23827;
        generic_ienumerator_class.122 = generic_ienumerator_class;
        D.23826 = (long unsigned int) i;
        D.23827 = D.23826 * 8;
        D.23847 = interfaces + D.23827;
        D.23879 = *D.23847;
        D.23880 = inflate_class_one_arg (generic_ienumerator_class.122, D.23879);
        *D.23847 = D.23880;
        i = i + 1;
        <D.19652>:
        if (i < interface_count) goto <D.19651>; else goto <D.19653>;
        <D.19653>:
        j = interface_count;
        if (eclass_is_valuetype == 0) goto <D.23881>; else goto <D.23882>;
        <D.23881>:
        D.23795 = eclass->flags;
        D.23796 = D.23795 & 32;
        if (D.23796 != 0) goto <D.23883>; else goto <D.23885>;
        <D.23885>:
        D.23798 = eclass->byval_arg.type;
        if (D.23798 == 19) goto <D.23883>; else goto <D.23886>;
        <D.23886>:
        D.23798 = eclass->byval_arg.type;
        if (D.23798 == 30) goto <D.23883>; else goto <D.23884>;
        <D.23883>:
        D.23887 = (long unsigned int) j;
        D.23888 = D.23887 * 8;
        D.23889 = interfaces + D.23888;
        generic_ienumerator_class.122 = generic_ienumerator_class;
        D.23824 = mono_defaults.object_class;
        D.23890 = inflate_class_one_arg (generic_ienumerator_class.122, D.23824);
        *D.23889 = D.23890;
        j = j + 1;
        goto <D.19656>;
        <D.23884>:
        i = 0;
        goto <D.19655>;
        <D.19654>:
        D.23887 = (long unsigned int) j;
        D.23888 = D.23887 * 8;
        D.23889 = interfaces + D.23888;
        generic_ienumerator_class.122 = generic_ienumerator_class;
        D.23825 = eclass->supertypes;
        D.23826 = (long unsigned int) i;
        D.23827 = D.23826 * 8;
        D.23828 = D.23825 + D.23827;
        D.23829 = *D.23828;
        D.23891 = inflate_class_one_arg (generic_ienumerator_class.122, D.23829);
        *D.23889 = D.23891;
        j = j + 1;
        i = i + 1;
        <D.19655>:
        D.23767 = eclass->idepth;
        D.23892 = (int) D.23767;
        if (D.23892 > i) goto <D.19654>; else goto <D.19656>;
        <D.19656>:
        i = 0;
        goto <D.19658>;
        <D.19657>:
        D.23887 = (long unsigned int) j;
        D.23888 = D.23887 * 8;
        D.23889 = interfaces + D.23888;
        generic_ienumerator_class.122 = generic_ienumerator_class;
        D.23835 = eclass->interfaces_packed;
        D.23826 = (long unsigned int) i;
        D.23827 = D.23826 * 8;
        D.23836 = D.23835 + D.23827;
        D.23837 = *D.23836;
        D.23893 = inflate_class_one_arg (generic_ienumerator_class.122, D.23837);
        *D.23889 = D.23893;
        j = j + 1;
        i = i + 1;
        <D.19658>:
        D.23789 = eclass->interface_offsets_count;
        D.23816 = (int) D.23789;
        if (D.23816 > i) goto <D.19657>; else goto <D.19659>;
        <D.19659>:
        goto <D.23894>;
        <D.23882>:
        j.123 = j;
        j = j.123 + 1;
        D.23896 = (long unsigned int) j.123;
        D.23897 = D.23896 * 8;
        D.23898 = interfaces + D.23897;
        generic_ienumerator_class.122 = generic_ienumerator_class;
        D.23760 = valuetype_types[0];
        original_rank.119 = (unsigned int) original_rank;
        D.23899 = array_class_get_if_rank (D.23760, original_rank.119);
        D.23900 = inflate_class_one_arg (generic_ienumerator_class.122, D.23899);
        *D.23898 = D.23900;
        <D.23894>:
        D.23750 = valuetype_types[1];
        if (D.23750 != 0B) goto <D.23901>; else goto <D.23902>;
        <D.23901>:
        D.23887 = (long unsigned int) j;
        D.23888 = D.23887 * 8;
        D.23889 = interfaces + D.23888;
        generic_ienumerator_class.122 = generic_ienumerator_class;
        D.23750 = valuetype_types[1];
        original_rank.119 = (unsigned int) original_rank;
        D.23903 = array_class_get_if_rank (D.23750, original_rank.119);
        D.23904 = inflate_class_one_arg (generic_ienumerator_class.122, D.23903);
        *D.23889 = D.23904;
        <D.23902>:
      }
      <D.23877>:
      *num = real_count;
      D.23705 = interfaces;
      return D.23705;
    }
  finally
    {
      valuetype_types = {CLOBBER};
    }
}


fill_valuetype_array_derived_types (struct MonoClass * * valuetype_types, struct MonoClass * eclass, int rank)
{
  struct MonoClass * D.23907;
  struct MonoClass * * D.23910;
  struct MonoClass * D.23911;
  struct MonoClass * D.23916;
  struct MonoClass * D.23919;
  struct MonoClass * D.23924;
  struct MonoClass * D.23927;
  struct MonoClass * D.23932;
  struct MonoClass * D.23935;
  long unsigned int D.23940;
  long unsigned int D.23941;
  struct MonoType * D.23944;
  struct MonoType * D.23947;
  struct MonoClass * D.23948;

  *valuetype_types = eclass;
  D.23907 = mono_defaults.int16_class;
  if (D.23907 == eclass) goto <D.23908>; else goto <D.23909>;
  <D.23908>:
  D.23910 = valuetype_types + 8;
  D.23911 = mono_defaults.uint16_class;
  *D.23910 = D.23911;
  goto <D.23912>;
  <D.23909>:
  D.23911 = mono_defaults.uint16_class;
  if (D.23911 == eclass) goto <D.23913>; else goto <D.23914>;
  <D.23913>:
  D.23910 = valuetype_types + 8;
  D.23907 = mono_defaults.int16_class;
  *D.23910 = D.23907;
  goto <D.23915>;
  <D.23914>:
  D.23916 = mono_defaults.int32_class;
  if (D.23916 == eclass) goto <D.23917>; else goto <D.23918>;
  <D.23917>:
  D.23910 = valuetype_types + 8;
  D.23919 = mono_defaults.uint32_class;
  *D.23910 = D.23919;
  goto <D.23920>;
  <D.23918>:
  D.23919 = mono_defaults.uint32_class;
  if (D.23919 == eclass) goto <D.23921>; else goto <D.23922>;
  <D.23921>:
  D.23910 = valuetype_types + 8;
  D.23916 = mono_defaults.int32_class;
  *D.23910 = D.23916;
  goto <D.23923>;
  <D.23922>:
  D.23924 = mono_defaults.int64_class;
  if (D.23924 == eclass) goto <D.23925>; else goto <D.23926>;
  <D.23925>:
  D.23910 = valuetype_types + 8;
  D.23927 = mono_defaults.uint64_class;
  *D.23910 = D.23927;
  goto <D.23928>;
  <D.23926>:
  D.23927 = mono_defaults.uint64_class;
  if (D.23927 == eclass) goto <D.23929>; else goto <D.23930>;
  <D.23929>:
  D.23910 = valuetype_types + 8;
  D.23924 = mono_defaults.int64_class;
  *D.23910 = D.23924;
  goto <D.23931>;
  <D.23930>:
  D.23932 = mono_defaults.byte_class;
  if (D.23932 == eclass) goto <D.23933>; else goto <D.23934>;
  <D.23933>:
  D.23910 = valuetype_types + 8;
  D.23935 = mono_defaults.sbyte_class;
  *D.23910 = D.23935;
  goto <D.23936>;
  <D.23934>:
  D.23935 = mono_defaults.sbyte_class;
  if (D.23935 == eclass) goto <D.23937>; else goto <D.23938>;
  <D.23937>:
  D.23910 = valuetype_types + 8;
  D.23932 = mono_defaults.byte_class;
  *D.23910 = D.23932;
  goto <D.23939>;
  <D.23938>:
  D.23940 = BIT_FIELD_REF <*eclass, 64, 256>;
  D.23941 = D.23940 & 576460752303423488;
  if (D.23941 != 0) goto <D.23942>; else goto <D.23943>;
  <D.23942>:
  D.23944 = mono_class_enum_basetype (eclass);
  if (D.23944 != 0B) goto <D.23945>; else goto <D.23946>;
  <D.23945>:
  D.23910 = valuetype_types + 8;
  D.23947 = mono_class_enum_basetype (eclass);
  D.23948 = mono_class_from_mono_type (D.23947);
  *D.23910 = D.23948;
  <D.23946>:
  <D.23943>:
  <D.23939>:
  <D.23936>:
  <D.23931>:
  <D.23928>:
  <D.23923>:
  <D.23920>:
  <D.23915>:
  <D.23912>:
}


array_class_get_if_rank (struct MonoClass * class, guint rank)
{
  struct MonoClass * D.23949;
  struct MonoClass * iftmp.124;

  if (rank != 0) goto <D.23951>; else goto <D.23952>;
  <D.23951>:
  iftmp.124 = mono_array_class_get (class, rank);
  goto <D.23953>;
  <D.23952>:
  iftmp.124 = class;
  <D.23953>:
  D.23949 = iftmp.124;
  return D.23949;
}


inflate_class_one_arg (struct MonoClass * gtype, struct MonoClass * arg0)
{
  struct MonoType * D.23955;
  struct MonoClass * D.23956;
  struct MonoType * args[1];

  try
    {
      D.23955 = &arg0->byval_arg;
      args[0] = D.23955;
      D.23956 = mono_class_bind_generic_parameters (gtype, 1, &args, 0);
      return D.23956;
    }
  finally
    {
      args = {CLOBBER};
    }
}


count_virtual_methods (struct MonoClass * class)
{
  struct MonoMethod * * D.23961;
  unsigned int D.23963;
  struct MonoImage * D.23965;
  long unsigned int D.23966;
  long unsigned int D.23967;
  struct MonoGenericClass * D.23969;
  unsigned char D.23970;
  int D.23973;
  long unsigned int D.23974;
  long unsigned int D.23975;
  struct MonoMethod * * D.23976;
  struct MonoMethod * D.23977;
  short unsigned int D.23978;
  unsigned int D.23979;
  unsigned int D.23982;
  unsigned int i.125;
  unsigned int D.23984;
  unsigned int D.23985;
  int D.23986;
  int i;
  int count;
  guint32 flags;

  count = 0;
  class = mono_class_get_generic_type_definition (class);
  D.23961 = class->methods;
  if (D.23961 != 0B) goto <D.23959>; else goto <D.23962>;
  <D.23962>:
  D.23963 = class->type_token;
  if (D.23963 == 0) goto <D.23959>; else goto <D.23964>;
  <D.23964>:
  D.23965 = class->image;
  D.23966 = BIT_FIELD_REF <*D.23965, 64, 192>;
  D.23967 = D.23966 & 268435456;
  if (D.23967 != 0) goto <D.23959>; else goto <D.23968>;
  <D.23968>:
  D.23969 = class->generic_class;
  if (D.23969 != 0B) goto <D.23959>; else goto <D.23960>;
  <D.23959>:
  mono_class_setup_methods (class);
  D.23970 = class->exception_type;
  if (D.23970 != 0) goto <D.23971>; else goto <D.23972>;
  <D.23971>:
  D.23973 = -1;
  return D.23973;
  <D.23972>:
  i = 0;
  goto <D.19675>;
  <D.19674>:
  D.23961 = class->methods;
  D.23974 = (long unsigned int) i;
  D.23975 = D.23974 * 8;
  D.23976 = D.23961 + D.23975;
  D.23977 = *D.23976;
  D.23978 = D.23977->flags;
  flags = (guint32) D.23978;
  D.23979 = flags & 64;
  if (D.23979 != 0) goto <D.23980>; else goto <D.23981>;
  <D.23980>:
  count = count + 1;
  <D.23981>:
  i = i + 1;
  <D.19675>:
  D.23982 = class->method.count;
  i.125 = (unsigned int) i;
  if (D.23982 > i.125) goto <D.19674>; else goto <D.19676>;
  <D.19676>:
  goto <D.19679>;
  <D.23960>:
  i = 0;
  goto <D.19678>;
  <D.19677>:
  D.23965 = class->image;
  D.23984 = class->method.first;
  i.125 = (unsigned int) i;
  D.23985 = D.23984 + i.125;
  D.23986 = (int) D.23985;
  flags = mono_metadata_decode_table_row_col (D.23965, 6, D.23986, 2);
  D.23979 = flags & 64;
  if (D.23979 != 0) goto <D.23987>; else goto <D.23988>;
  <D.23987>:
  count = count + 1;
  <D.23988>:
  i = i + 1;
  <D.19678>:
  D.23982 = class->method.count;
  i.125 = (unsigned int) i;
  if (D.23982 > i.125) goto <D.19677>; else goto <D.19679>;
  <D.19679>:
  D.23973 = count;
  return D.23973;
}


find_array_interface (struct MonoClass * klass, const char * name)
{
  struct MonoClass * * D.23990;
  long unsigned int D.23991;
  long unsigned int D.23992;
  struct MonoClass * * D.23993;
  struct MonoClass * D.23994;
  const char * D.23995;
  int D.23996;
  int D.23999;
  short unsigned int D.24000;
  int D.24001;
  int i;

  i = 0;
  goto <D.19666>;
  <D.19665>:
  D.23990 = klass->interfaces;
  D.23991 = (long unsigned int) i;
  D.23992 = D.23991 * 8;
  D.23993 = D.23990 + D.23992;
  D.23994 = *D.23993;
  D.23995 = D.23994->name;
  D.23996 = strcmp (D.23995, name);
  if (D.23996 == 0) goto <D.23997>; else goto <D.23998>;
  <D.23997>:
  D.23999 = i;
  return D.23999;
  <D.23998>:
  i = i + 1;
  <D.19666>:
  D.24000 = klass->interface_count;
  D.24001 = (int) D.24000;
  if (D.24001 > i) goto <D.19665>; else goto <D.19667>;
  <D.19667>:
  D.23999 = -1;
  return D.23999;
}


find_interface_offset (int num_ifaces, struct MonoClass * * interfaces_full, int * interface_offsets_full, struct MonoClass * ic)
{
  int D.24005;
  long unsigned int D.24006;
  long unsigned int D.24007;
  int * D.24008;
  int i;

  i = find_interface (num_ifaces, interfaces_full, ic);
  if (1 != 0) goto <D.24003>; else goto <D.24004>;
  <D.24003>:
  D.24006 = (long unsigned int) i;
  D.24007 = D.24006 * 4;
  D.24008 = interface_offsets_full + D.24007;
  D.24005 = *D.24008;
  return D.24005;
  <D.24004>:
  D.24005 = -1;
  return D.24005;
}


find_interface (int num_ifaces, struct MonoClass * * interfaces_full, struct MonoClass * ic)
{
  int D.24012;
  int D.24015;
  long unsigned int D.24016;
  long unsigned int D.24017;
  struct MonoClass * * D.24018;
  struct MonoClass * D.24019;
  short unsigned int D.24028;
  short unsigned int D.24029;
  int m;
  int l;

  l = 0;
  if (num_ifaces == 0) goto <D.24010>; else goto <D.24011>;
  <D.24010>:
  D.24012 = -1;
  return D.24012;
  <D.24011>:
  <D.19687>:
  if (l > num_ifaces) goto <D.24013>; else goto <D.24014>;
  <D.24013>:
  D.24012 = -1;
  return D.24012;
  <D.24014>:
  D.24015 = l + num_ifaces;
  m = D.24015 / 2;
  D.24016 = (long unsigned int) m;
  D.24017 = D.24016 * 8;
  D.24018 = interfaces_full + D.24017;
  D.24019 = *D.24018;
  if (D.24019 == ic) goto <D.24020>; else goto <D.24021>;
  <D.24020>:
  D.24012 = m;
  return D.24012;
  <D.24021>:
  if (l == num_ifaces) goto <D.24022>; else goto <D.24023>;
  <D.24022>:
  D.24012 = -1;
  return D.24012;
  <D.24023>:
  D.24016 = (long unsigned int) m;
  D.24017 = D.24016 * 8;
  D.24018 = interfaces_full + D.24017;
  D.24019 = *D.24018;
  if (D.24019 == 0B) goto <D.24024>; else goto <D.24027>;
  <D.24027>:
  D.24016 = (long unsigned int) m;
  D.24017 = D.24016 * 8;
  D.24018 = interfaces_full + D.24017;
  D.24019 = *D.24018;
  D.24028 = D.24019->interface_id;
  D.24029 = ic->interface_id;
  if (D.24028 > D.24029) goto <D.24024>; else goto <D.24025>;
  <D.24024>:
  num_ifaces = m + -1;
  goto <D.24026>;
  <D.24025>:
  l = m + 1;
  <D.24026>:
  goto <D.19687>;
}


set_interface_and_offset (int num_ifaces, struct MonoClass * * interfaces_full, int * interface_offsets_full, struct MonoClass * ic, int offset, mono_bool force_set)
{
  mono_bool D.24035;
  long unsigned int D.24036;
  long unsigned int D.24037;
  int * D.24038;
  long unsigned int D.24039;
  struct MonoClass * * D.24040;
  struct MonoClass * D.24041;
  short unsigned int D.24044;
  short unsigned int D.24045;
  long unsigned int D.24049;
  long unsigned int D.24050;
  struct MonoClass * * D.24051;
  struct MonoClass * D.24052;
  sizetype D.24053;
  sizetype D.24054;
  sizetype D.24055;
  struct MonoClass * * D.24056;
  int D.24057;
  long unsigned int D.24058;
  long unsigned int D.24059;
  sizetype D.24060;
  int * D.24061;
  long unsigned int D.24062;
  int i;

  i = find_interface (num_ifaces, interfaces_full, ic);
  if (i >= 0) goto <D.24031>; else goto <D.24032>;
  <D.24031>:
  if (force_set == 0) goto <D.24033>; else goto <D.24034>;
  <D.24033>:
  D.24035 = 1;
  return D.24035;
  <D.24034>:
  D.24036 = (long unsigned int) i;
  D.24037 = D.24036 * 4;
  D.24038 = interface_offsets_full + D.24037;
  *D.24038 = offset;
  D.24035 = 0;
  return D.24035;
  <D.24032>:
  i = 0;
  goto <D.19711>;
  <D.19710>:
  D.24036 = (long unsigned int) i;
  D.24039 = D.24036 * 8;
  D.24040 = interfaces_full + D.24039;
  D.24041 = *D.24040;
  if (D.24041 != 0B) goto <D.24042>; else goto <D.24043>;
  <D.24042>:
  {
    int end;

    D.24036 = (long unsigned int) i;
    D.24039 = D.24036 * 8;
    D.24040 = interfaces_full + D.24039;
    D.24041 = *D.24040;
    D.24044 = D.24041->interface_id;
    D.24045 = ic->interface_id;
    if (D.24044 < D.24045) goto <D.24046>; else goto <D.24047>;
    <D.24046>:
    // predicted unlikely by continue predictor.
    goto <D.19705>;
    <D.24047>:
    end = i + 1;
    goto <D.19707>;
    <D.19706>:
    end = end + 1;
    <D.19707>:
    if (end < num_ifaces) goto <D.24048>; else goto <D.19708>;
    <D.24048>:
    D.24049 = (long unsigned int) end;
    D.24050 = D.24049 * 8;
    D.24051 = interfaces_full + D.24050;
    D.24052 = *D.24051;
    if (D.24052 != 0B) goto <D.19706>; else goto <D.19708>;
    <D.19708>:
    D.24053 = (sizetype) i;
    D.24054 = D.24053 + 1;
    D.24055 = D.24054 * 8;
    D.24056 = interfaces_full + D.24055;
    D.24036 = (long unsigned int) i;
    D.24039 = D.24036 * 8;
    D.24040 = interfaces_full + D.24039;
    D.24057 = end - i;
    D.24058 = (long unsigned int) D.24057;
    D.24059 = D.24058 * 8;
    memmove (D.24056, D.24040, D.24059);
    D.24053 = (sizetype) i;
    D.24054 = D.24053 + 1;
    D.24060 = D.24054 * 4;
    D.24061 = interface_offsets_full + D.24060;
    D.24036 = (long unsigned int) i;
    D.24037 = D.24036 * 4;
    D.24038 = interface_offsets_full + D.24037;
    D.24057 = end - i;
    D.24058 = (long unsigned int) D.24057;
    D.24062 = D.24058 * 4;
    memmove (D.24061, D.24038, D.24062);
  }
  <D.24043>:
  D.24036 = (long unsigned int) i;
  D.24039 = D.24036 * 8;
  D.24040 = interfaces_full + D.24039;
  *D.24040 = ic;
  D.24036 = (long unsigned int) i;
  D.24037 = D.24036 * 4;
  D.24038 = interface_offsets_full + D.24037;
  *D.24038 = offset;
  goto <D.19709>;
  <D.19705>:
  i = i + 1;
  <D.19711>:
  if (i < num_ifaces) goto <D.19710>; else goto <D.19709>;
  <D.19709>:
  D.24035 = 0;
  return D.24035;
}


__attribute__((__artificial__, __gnu_inline__, __always_inline__, __nothrow__, __leaf__))
memmove (void * __dest, const void * __src, size_t __len)
{
  void * D.24064;
  long unsigned int D.24065;

  D.24065 = __builtin_object_size (__dest, 0);
  D.24064 = __builtin___memmove_chk (__dest, __src, __len, D.24065);
  return D.24064;
}


__attribute__((visibility ("hidden")))
mono_class_check_vtable_constraints (struct MonoClass * class, struct GList * in_setup)
{
  struct MonoGenericClass * D.24067;
  gboolean D.24070;
  unsigned char D.24071;
  _Bool D.24072;
  struct MonoClass * D.24073;
  struct MonoClass * D.24074;
  unsigned char D.24075;
  gchar * D.24078;
  struct MonoType * D.24079;
  unsigned char D.24080;
  int D.24085;
  int D.24087;
  int D.24088;
  gchar * D.24091;
  <unnamed-unsigned:22> D.24092;
  int D.24093;
  struct MonoGenericInst * ginst;
  int i;

  D.24067 = class->generic_class;
  if (D.24067 == 0B) goto <D.24068>; else goto <D.24069>;
  <D.24068>:
  mono_class_setup_vtable_full (class, in_setup);
  D.24071 = class->exception_type;
  D.24072 = D.24071 == 0;
  D.24070 = (gboolean) D.24072;
  return D.24070;
  <D.24069>:
  D.24073 = mono_class_get_generic_type_definition (class);
  mono_class_setup_vtable_full (D.24073, in_setup);
  D.24067 = class->generic_class;
  D.24074 = D.24067->container_class;
  D.24075 = D.24074->exception_type;
  if (D.24075 != 0) goto <D.24076>; else goto <D.24077>;
  <D.24076>:
  D.24078 = monoeg_strdup ("Failed to load generic definition vtable");
  mono_class_set_failure (class, 7, D.24078);
  D.24070 = 0;
  return D.24070;
  <D.24077>:
  D.24067 = class->generic_class;
  ginst = D.24067->context.class_inst;
  i = 0;
  goto <D.19811>;
  <D.19810>:
  {
    struct MonoClass * arg;

    D.24079 = ginst->type_argv[i];
    D.24080 = D.24079->type;
    if (D.24080 != 21) goto <D.24081>; else goto <D.24082>;
    <D.24081>:
    // predicted unlikely by continue predictor.
    goto <D.19809>;
    <D.24082>:
    D.24079 = ginst->type_argv[i];
    arg = mono_class_from_mono_type (D.24079);
    D.24085 = mono_class_has_gtd_parent (class, arg);
    if (D.24085 != 0) goto <D.24083>; else goto <D.24086>;
    <D.24086>:
    D.24087 = mono_class_has_gtd_parent (arg, class);
    if (D.24087 != 0) goto <D.24083>; else goto <D.24084>;
    <D.24083>:
    // predicted unlikely by continue predictor.
    goto <D.19809>;
    <D.24084>:
    D.24088 = mono_class_check_vtable_constraints (arg, in_setup);
    if (D.24088 == 0) goto <D.24089>; else goto <D.24090>;
    <D.24089>:
    D.24091 = monoeg_g_strdup_printf ("Failed to load generic parameter %d", i);
    mono_class_set_failure (class, 7, D.24091);
    D.24070 = 0;
    return D.24070;
    <D.24090>:
  }
  <D.19809>:
  i = i + 1;
  <D.19811>:
  D.24092 = ginst->type_argc;
  D.24093 = (int) D.24092;
  if (D.24093 > i) goto <D.19810>; else goto <D.19812>;
  <D.19812>:
  D.24070 = 1;
  return D.24070;
}


mono_class_setup_vtable_full (struct MonoClass * class, struct GList * in_setup)
{
  struct MonoMethod * * D.24095;
  unsigned int D.24100;
  unsigned int D.24101;
  unsigned char D.24103;
  unsigned char D.24105;
  struct GList * D.24108;
  long unsigned int D.24113;
  long unsigned int D.24114;
  struct MonoGenericClass * D.24115;
  int D.24118;
  struct MonoClass * D.24121;
  struct MonoImage * D.24123;
  long unsigned int D.24124;
  long unsigned int D.24125;
  struct MonoMethod * * overrides.126;
  int onum.127;
  gchar * D.24134;
  struct MonoMethod * * overrides;
  struct MonoGenericContext * context;
  guint32 type_token;
  int onum;
  gboolean ok;

  try
    {
      onum = 0;
      ok = 1;
      D.24095 = class->vtable;
      if (D.24095 != 0B) goto <D.24096>; else goto <D.24097>;
      <D.24096>:
      return;
      <D.24097>:
      D.24100 = class->flags;
      D.24101 = D.24100 & 32;
      if (D.24101 != 0) goto <D.24098>; else goto <D.24102>;
      <D.24102>:
      D.24103 = class->byval_arg.type;
      if (D.24103 == 19) goto <D.24098>; else goto <D.24104>;
      <D.24104>:
      D.24103 = class->byval_arg.type;
      if (D.24103 == 30) goto <D.24098>; else goto <D.24099>;
      <D.24098>:
      mono_class_setup_methods (class);
      return;
      <D.24099>:
      D.24105 = class->exception_type;
      if (D.24105 != 0) goto <D.24106>; else goto <D.24107>;
      <D.24106>:
      return;
      <D.24107>:
      D.24108 = monoeg_g_list_find (in_setup, class);
      if (D.24108 != 0B) goto <D.24109>; else goto <D.24110>;
      <D.24109>:
      return;
      <D.24110>:
      mono_loader_lock ();
      D.24095 = class->vtable;
      if (D.24095 != 0B) goto <D.24111>; else goto <D.24112>;
      <D.24111>:
      mono_loader_unlock ();
      return;
      <D.24112>:
      D.24113 = mono_stats.generic_vtable_count;
      D.24114 = D.24113 + 1;
      mono_stats.generic_vtable_count = D.24114;
      in_setup = monoeg_g_list_prepend (in_setup, class);
      D.24115 = class->generic_class;
      if (D.24115 != 0B) goto <D.24116>; else goto <D.24117>;
      <D.24116>:
      D.24118 = mono_class_check_vtable_constraints (class, in_setup);
      if (D.24118 == 0) goto <D.24119>; else goto <D.24120>;
      <D.24119>:
      mono_loader_unlock ();
      monoeg_g_list_remove (in_setup, class);
      return;
      <D.24120>:
      context = mono_class_get_context (class);
      D.24115 = class->generic_class;
      D.24121 = D.24115->container_class;
      type_token = D.24121->type_token;
      goto <D.24122>;
      <D.24117>:
      context = class->generic_container;
      type_token = class->type_token;
      <D.24122>:
      D.24123 = class->image;
      D.24124 = BIT_FIELD_REF <*D.24123, 64, 192>;
      D.24125 = D.24124 & 268435456;
      if (D.24125 != 0) goto <D.24126>; else goto <D.24127>;
      <D.24126>:
      mono_reflection_get_dynamic_overrides (class, &overrides, &onum);
      goto <D.24128>;
      <D.24127>:
      D.24123 = class->image;
      ok = mono_class_get_overrides_full (D.24123, type_token, &overrides, &onum, context);
      <D.24128>:
      if (ok != 0) goto <D.24129>; else goto <D.24130>;
      <D.24129>:
      overrides.126 = overrides;
      onum.127 = onum;
      mono_class_setup_vtable_general (class, overrides.126, onum.127, in_setup);
      goto <D.24133>;
      <D.24130>:
      D.24134 = monoeg_strdup ("Could not load list of method overrides");
      mono_class_set_failure (class, 7, D.24134);
      <D.24133>:
      overrides.126 = overrides;
      monoeg_g_free (overrides.126);
      mono_loader_unlock ();
      monoeg_g_list_remove (in_setup, class);
      return;
    }
  finally
    {
      overrides = {CLOBBER};
      onum = {CLOBBER};
    }
}


mono_class_has_gtd_parent (struct MonoClass * klass, struct MonoClass * parent)
{
  gboolean D.24137;
  int iftmp.128;
  short unsigned int D.24141;
  short unsigned int D.24142;
  struct MonoClass * * D.24144;
  long unsigned int D.24145;
  long unsigned int D.24146;
  sizetype D.24147;
  struct MonoClass * * D.24148;
  struct MonoClass * D.24149;
  struct MonoClass * D.24150;

  klass = mono_class_get_generic_type_definition (klass);
  parent = mono_class_get_generic_type_definition (parent);
  mono_class_setup_supertypes (klass);
  mono_class_setup_supertypes (parent);
  D.24141 = klass->idepth;
  D.24142 = parent->idepth;
  if (D.24141 >= D.24142) goto <D.24143>; else goto <D.24139>;
  <D.24143>:
  D.24144 = klass->supertypes;
  D.24142 = parent->idepth;
  D.24145 = (long unsigned int) D.24142;
  D.24146 = D.24145 * 8;
  D.24147 = D.24146 + 18446744073709551608;
  D.24148 = D.24144 + D.24147;
  D.24149 = *D.24148;
  D.24150 = mono_class_get_generic_type_definition (D.24149);
  if (D.24150 == parent) goto <D.24151>; else goto <D.24139>;
  <D.24151>:
  iftmp.128 = 1;
  goto <D.24140>;
  <D.24139>:
  iftmp.128 = 0;
  <D.24140>:
  D.24137 = iftmp.128;
  return D.24137;
}


__attribute__((visibility ("hidden")))
mono_class_setup_vtable (struct MonoClass * class)
{
  mono_class_setup_vtable_full (class, 0B);
}


__attribute__((visibility ("hidden")))
mono_class_setup_vtable_general (struct MonoClass * class, struct MonoMethod * * overrides, int onum, struct GList * in_setup)
{
  struct MonoMethod * * D.24153;
  int D.24158;
  int D.24161;
  const char * D.24164;
  gchar * D.24165;
  void * * D.24168;
  long unsigned int D.24169;
  long unsigned int D.24170;
  void * * D.24171;
  unsigned int D.24172;
  unsigned int max_vtsize.129;
  unsigned int D.24174;
  unsigned int D.24175;
  unsigned int i.130;
  struct MonoClass * D.24177;
  unsigned char D.24180;
  gchar * D.24183;
  int D.24184;
  unsigned int D.24185;
  unsigned int D.24186;
  int D.24187;
  long unsigned int D.24190;
  long unsigned int D.24191;
  short unsigned int D.24194;
  struct MonoGenericClass * D.24195;
  unsigned char D.24198;
  int D.24201;
  unsigned int D.24202;
  unsigned int D.24203;
  int D.24204;
  struct MonoMethod * * D.24205;
  struct MonoMethod * * D.24206;
  struct MonoMethod * D.24207;
  struct MonoGenericContext * D.24210;
  int D.24211;
  const char * D.24214;
  struct MonoMethod * * D.24215;
  struct MonoMethod * D.24216;
  short int D.24217;
  struct MonoMethod * * D.24218;
  struct MonoMethod * * D.24221;
  struct MonoMethod * * D.24224;
  struct MonoMethod * D.24225;
  short int D.24226;
  struct MonoMethod * * D.24229;
  struct MonoMethod * D.24230;
  short int D.24231;
  unsigned int i.131;
  struct MonoMethod * * D.24237;
  int D.24238;
  long unsigned int D.24239;
  long unsigned int D.24240;
  struct MonoClass * * D.24241;
  long unsigned int D.24242;
  long unsigned int D.24243;
  struct MonoClass * * D.24244;
  int D.24247;
  long unsigned int D.24248;
  long unsigned int D.24249;
  struct MonoMethod * * D.24250;
  int D.24251;
  long unsigned int D.24252;
  long unsigned int D.24253;
  struct MonoMethod * * D.24254;
  struct MonoMethod * D.24255;
  unsigned int D.24256;
  unsigned int j.132;
  unsigned char D.24259;
  short unsigned int D.24260;
  int D.24261;
  int D.24262;
  short int D.24265;
  short int D.24268;
  int D.24270;
  _Bool D.24271;
  long int D.24272;
  long int D.24273;
  long unsigned int D.24276;
  long unsigned int D.24277;
  struct MonoMethod * * D.24278;
  int D.24279;
  long unsigned int D.24280;
  long unsigned int D.24281;
  struct MonoMethod * * D.24282;
  struct MonoClass * D.24285;
  unsigned int D.24286;
  unsigned int D.24287;
  unsigned char D.24289;
  int D.24293;
  long unsigned int D.24294;
  long unsigned int D.24295;
  struct MonoMethod * * D.24296;
  sizetype D.24297;
  sizetype D.24298;
  sizetype D.24299;
  struct MonoMethod * * D.24300;
  struct MonoMethod * D.24301;
  struct MonoMethod * D.24302;
  short int D.24303;
  struct MonoMethod * D.24306;
  <unnamed type> D.24307;
  struct MonoClass * * D.24311;
  struct MonoClass * * D.24312;
  unsigned char D.24313;
  struct MonoClass * * D.24317;
  long unsigned int D.24318;
  long unsigned int D.24319;
  struct MonoClass * * D.24320;
  struct MonoClass * D.24321;
  short unsigned int D.24324;
  int D.24325;
  struct MonoMethod * * D.24327;
  long unsigned int D.24328;
  long unsigned int D.24329;
  struct MonoMethod * * D.24330;
  short int D.24331;
  int D.24332;
  struct MonoMethod * iftmp.133;
  short unsigned int D.24337;
  int D.24338;
  int D.24339;
  long unsigned int D.24344;
  long unsigned int D.24345;
  struct MonoMethod * * D.24346;
  struct MonoMethod * D.24347;
  _Bool D.24348;
  int D.24349;
  int D.24350;
  short int D.24353;
  short int D.24356;
  int D.24362;
  struct MonoMethod * * D.24363;
  long unsigned int D.24364;
  long unsigned int D.24365;
  struct MonoMethod * * D.24366;
  int D.24369;
  short int D.24372;
  _Bool D.24377;
  long int D.24378;
  long int D.24379;
  unsigned int D.24382;
  unsigned int im_index.134;
  short unsigned int D.24384;
  int D.24385;
  unsigned int D.24386;
  unsigned int D.24387;
  long unsigned int D.24390;
  long unsigned int D.24391;
  struct MonoMethod * * D.24392;
  short int D.24393;
  int D.24394;
  short unsigned int D.24395;
  int D.24396;
  int D.24397;
  long unsigned int D.24400;
  long unsigned int D.24401;
  struct MonoMethod * * D.24402;
  struct MonoMethod * D.24403;
  unsigned int im_index.135;
  short unsigned int D.24407;
  int D.24408;
  int D.24409;
  const char * D.24415;
  const char * D.24416;
  int D.24417;
  int D.24420;
  short unsigned int D.24425;
  int D.24426;
  int D.24427;
  <unnamed type> D.24430;
  int D.24434;
  int D.24437;
  gchar * D.24440;
  short int D.24441;
  int D.24442;
  _Bool D.24443;
  long int D.24444;
  long int D.24445;
  unsigned char D.24450;
  short int D.24455;
  unsigned int D.24456;
  unsigned int D.24457;
  int cur_slot.136;
  short int D.24465;
  int D.24466;
  long unsigned int D.24469;
  long unsigned int D.24470;
  struct MonoMethod * * D.24471;
  struct MonoClass * D.24472;
  unsigned int D.24473;
  unsigned int D.24474;
  unsigned char D.24477;
  short int D.24482;
  _Bool D.24483;
  long int D.24484;
  long int D.24485;
  long unsigned int D.24488;
  long unsigned int D.24489;
  struct MonoMethod * * D.24490;
  <unnamed type> D.24493;
  struct MonoMethod * D.24496;
  struct MonoMethod * * D.24499;
  struct MonoMethod * D.24500;
  short unsigned int D.24510;
  int D.24511;
  int D.24512;
  char * iftmp.137;
  gchar * D.24517;
  int D.24520;
  int D.24521;
  int D.24523;
  _Bool D.24526;
  long int D.24527;
  long int D.24528;
  struct MonoMethod * * D.24535;
  long unsigned int D.24536;
  long unsigned int D.24537;
  int D.24538;
  unsigned int D.24540;
  unsigned int D.24541;
  int D.24542;
  int mono_print_vtable.138;
  int D.24546;
  guint8 * D.24549;
  int D.24550;
  sizetype D.24551;
  guint8 * D.24552;
  unsigned char D.24553;
  int D.24554;
  int D.24555;
  int D.24556;
  int D.24557;
  struct MonoType * D.24560;
  char * D.24561;
  short int D.24564;
  int D.24565;
  char * D.24566;
  const char * D.24569;
  const char * D.24570;
  struct MonoClass * * D.24571;
  int D.24572;
  int D.24573;
  short unsigned int D.24574;
  int D.24575;
  struct MonoType * D.24576;
  char * D.24577;
  struct MonoClass * * D.24578;
  struct MonoClass * * D.24579;
  int D.24580;
  int D.24581;
  char * D.24582;
  short unsigned int D.24583;
  int D.24584;
  gchar * D.24585;
  struct MonoError error;
  struct MonoClass * k;
  struct MonoClass * ic;
  struct MonoMethod * * vtable;
  int i;
  int max_vtsize;
  int max_iid;
  int cur_slot;
  struct GPtrArray * ifaces;
  struct GHashTable * override_map;
  gboolean security_enabled;
  struct MonoMethod * cm;
  void * class_iter;
  struct GSList * virt_methods;
  struct GSList * l;
  int stelemref_slot;
  void fail = <<< error >>>;

  try
    {
      max_vtsize = 0;
      cur_slot = 0;
      ifaces = 0B;
      override_map = 0B;
      security_enabled = mono_is_security_manager_active ();
      virt_methods = 0B;
      stelemref_slot = 0;
      D.24153 = class->vtable;
      if (D.24153 != 0B) goto <D.24154>; else goto <D.24155>;
      <D.24154>:
      return;
      <D.24155>:
      if (overrides != 0B) goto <D.24156>; else goto <D.24157>;
      <D.24156>:
      D.24158 = verify_class_overrides (class, overrides, onum);
      if (D.24158 == 0) goto <D.24159>; else goto <D.24160>;
      <D.24159>:
      return;
      <D.24160>:
      <D.24157>:
      ifaces = mono_class_get_implemented_interfaces (class, &error);
      D.24161 = mono_error_ok (&error);
      if (D.24161 == 0) goto <D.24162>; else goto <D.24163>;
      <D.24162>:
      {
        char * name;

        name = mono_type_get_full_name (class);
        D.24164 = mono_error_get_message (&error);
        D.24165 = monoeg_g_strdup_printf ("Could not resolve %s interfaces due to %s", name, D.24164);
        mono_class_set_failure (class, 7, D.24165);
        monoeg_g_free (name);
        mono_error_cleanup (&error);
        return;
      }
      <D.24163>:
      if (ifaces != 0B) goto <D.24166>; else goto <D.24167>;
      <D.24166>:
      i = 0;
      goto <D.19915>;
      <D.19914>:
      {
        struct MonoClass * ic;

        D.24168 = ifaces->pdata;
        D.24169 = (long unsigned int) i;
        D.24170 = D.24169 * 8;
        D.24171 = D.24168 + D.24170;
        ic = *D.24171;
        D.24172 = ic->method.count;
        max_vtsize.129 = (unsigned int) max_vtsize;
        D.24174 = D.24172 + max_vtsize.129;
        max_vtsize = (int) D.24174;
      }
      i = i + 1;
      <D.19915>:
      D.24175 = ifaces->len;
      i.130 = (unsigned int) i;
      if (D.24175 > i.130) goto <D.19914>; else goto <D.19916>;
      <D.19916>:
      monoeg_g_ptr_array_free (ifaces, 1);
      ifaces = 0B;
      <D.24167>:
      D.24177 = class->parent;
      if (D.24177 != 0B) goto <D.24178>; else goto <D.24179>;
      <D.24178>:
      D.24177 = class->parent;
      mono_class_init (D.24177);
      D.24177 = class->parent;
      mono_class_setup_vtable_full (D.24177, in_setup);
      D.24177 = class->parent;
      D.24180 = D.24177->exception_type;
      if (D.24180 != 0) goto <D.24181>; else goto <D.24182>;
      <D.24181>:
      {
        char * name;

        D.24177 = class->parent;
        name = mono_type_get_full_name (D.24177);
        D.24183 = monoeg_g_strdup_printf ("Parent %s failed to load", name);
        mono_class_set_failure (class, 7, D.24183);
        monoeg_g_free (name);
        return;
      }
      <D.24182>:
      D.24177 = class->parent;
      D.24184 = D.24177->vtable_size;
      max_vtsize = D.24184 + max_vtsize;
      D.24177 = class->parent;
      cur_slot = D.24177->vtable_size;
      <D.24179>:
      D.24185 = class->method.count;
      max_vtsize.129 = (unsigned int) max_vtsize;
      D.24186 = D.24185 + max_vtsize.129;
      max_vtsize = (int) D.24186;
      D.24187 = mono_class_need_stelemref_method (class);
      if (D.24187 != 0) goto <D.24188>; else goto <D.24189>;
      <D.24188>:
      stelemref_slot = cur_slot;
      max_vtsize = max_vtsize + 1;
      cur_slot = cur_slot + 1;
      <D.24189>:
      D.24190 = (long unsigned int) max_vtsize;
      D.24191 = D.24190 * 8;
      vtable = __builtin_alloca (D.24191);
      D.24190 = (long unsigned int) max_vtsize;
      D.24191 = D.24190 * 8;
      memset (vtable, 0, D.24191);
      cur_slot = setup_interface_offsets (class, cur_slot, 1);
      if (cur_slot == -1) goto <D.24192>; else goto <D.24193>;
      <D.24192>:
      return;
      <D.24193>:
      D.24194 = class->max_interface_id;
      max_iid = (int) D.24194;
      D.24195 = class->generic_class;
      if (D.24195 != 0B) goto <D.24196>; else goto <D.24197>;
      <D.24196>:
      {
        struct MonoError error;
        struct MonoClass * gklass;
        struct MonoMethod * * tmp;

        try
          {
            D.24195 = class->generic_class;
            gklass = D.24195->container_class;
            mono_class_setup_vtable_full (gklass, in_setup);
            D.24198 = gklass->exception_type;
            if (D.24198 != 0) goto <D.24199>; else goto <D.24200>;
            <D.24199>:
            mono_class_set_failure (class, 7, 0B);
            return;
            <D.24200>:
            D.24201 = gklass->vtable_size;
            D.24202 = (unsigned int) D.24201;
            D.24203 = D.24202 * 8;
            D.24204 = (int) D.24203;
            tmp = mono_class_alloc0 (class, D.24204);
            D.24201 = gklass->vtable_size;
            class->vtable_size = D.24201;
            i = 0;
            goto <D.19924>;
            <D.19923>:
            D.24205 = gklass->vtable;
            D.24169 = (long unsigned int) i;
            D.24170 = D.24169 * 8;
            D.24206 = D.24205 + D.24170;
            D.24207 = *D.24206;
            if (D.24207 != 0B) goto <D.24208>; else goto <D.24209>;
            <D.24208>:
            {
              struct MonoMethod * inflated;

              D.24205 = gklass->vtable;
              D.24169 = (long unsigned int) i;
              D.24170 = D.24169 * 8;
              D.24206 = D.24205 + D.24170;
              D.24207 = *D.24206;
              D.24210 = mono_class_get_context (class);
              inflated = mono_class_inflate_generic_method_full_checked (D.24207, class, D.24210, &error);
              D.24211 = mono_error_ok (&error);
              if (D.24211 == 0) goto <D.24212>; else goto <D.24213>;
              <D.24212>:
              {
                char * err_msg;

                D.24214 = mono_error_get_message (&error);
                err_msg = monoeg_g_strdup_printf ("Could not inflate method due to %s", D.24214);
                mono_class_set_failure (class, 7, err_msg);
                monoeg_g_free (err_msg);
                mono_error_cleanup (&error);
                return;
              }
              <D.24213>:
              D.24169 = (long unsigned int) i;
              D.24170 = D.24169 * 8;
              D.24215 = tmp + D.24170;
              *D.24215 = inflated;
              D.24169 = (long unsigned int) i;
              D.24170 = D.24169 * 8;
              D.24215 = tmp + D.24170;
              D.24216 = *D.24215;
              D.24205 = gklass->vtable;
              D.24169 = (long unsigned int) i;
              D.24170 = D.24169 * 8;
              D.24206 = D.24205 + D.24170;
              D.24207 = *D.24206;
              D.24217 = D.24207->slot;
              D.24216->slot = D.24217;
            }
            <D.24209>:
            i = i + 1;
            <D.19924>:
            D.24201 = gklass->vtable_size;
            if (D.24201 > i) goto <D.19923>; else goto <D.19925>;
            <D.19925>:
            mono_memory_barrier ();
            class->vtable = tmp;
            D.24218 = class->methods;
            if (D.24218 != 0B) goto <D.24219>; else goto <D.24220>;
            <D.24219>:
            D.24221 = gklass->methods;
            if (D.24221 != 0B) goto <D.24222>; else goto <D.24223>;
            <D.24222>:
            i = 0;
            goto <D.19927>;
            <D.19926>:
            D.24218 = class->methods;
            D.24169 = (long unsigned int) i;
            D.24170 = D.24169 * 8;
            D.24224 = D.24218 + D.24170;
            D.24225 = *D.24224;
            D.24226 = D.24225->slot;
            if (D.24226 == -1) goto <D.24227>; else goto <D.24228>;
            <D.24227>:
            D.24218 = class->methods;
            D.24169 = (long unsigned int) i;
            D.24170 = D.24169 * 8;
            D.24224 = D.24218 + D.24170;
            D.24225 = *D.24224;
            D.24221 = gklass->methods;
            D.24169 = (long unsigned int) i;
            D.24170 = D.24169 * 8;
            D.24229 = D.24221 + D.24170;
            D.24230 = *D.24229;
            D.24231 = D.24230->slot;
            D.24225->slot = D.24231;
            <D.24228>:
            i = i + 1;
            <D.19927>:
            D.24185 = class->method.count;
            i.131 = (unsigned int) i;
            if (D.24185 > i.131) goto <D.19926>; else goto <D.19928>;
            <D.19928>:
            <D.24223>:
            <D.24220>:
            return;
          }
        finally
          {
            error = {CLOBBER};
          }
      }
      <D.24197>:
      D.24177 = class->parent;
      if (D.24177 != 0B) goto <D.24233>; else goto <D.24234>;
      <D.24233>:
      D.24177 = class->parent;
      D.24184 = D.24177->vtable_size;
      if (D.24184 != 0) goto <D.24235>; else goto <D.24236>;
      <D.24235>:
      {
        struct MonoClass * parent;
        int i;

        parent = class->parent;
        D.24237 = parent->vtable;
        D.24238 = parent->vtable_size;
        D.24239 = (long unsigned int) D.24238;
        D.24240 = D.24239 * 8;
        memcpy (vtable, D.24237, D.24240);
        i = 0;
        goto <D.19939>;
        <D.19938>:
        {
          struct MonoClass * parent_interface;
          int interface_offset;

          D.24241 = parent->interfaces_packed;
          D.24242 = (long unsigned int) i;
          D.24243 = D.24242 * 8;
          D.24244 = D.24241 + D.24243;
          parent_interface = *D.24244;
          interface_offset = mono_class_interface_offset (class, parent_interface);
          D.24238 = parent->vtable_size;
          if (D.24238 <= interface_offset) goto <D.24245>; else goto <D.24246>;
          <D.24245>:
          {
            int parent_interface_offset;
            int j;

            parent_interface_offset = mono_class_interface_offset (parent, parent_interface);
            mono_class_setup_methods (parent_interface);
            j = 0;
            goto <D.19936>;
            <D.19935>:
            D.24247 = interface_offset + j;
            D.24248 = (long unsigned int) D.24247;
            D.24249 = D.24248 * 8;
            D.24250 = vtable + D.24249;
            D.24237 = parent->vtable;
            D.24251 = parent_interface_offset + j;
            D.24252 = (long unsigned int) D.24251;
            D.24253 = D.24252 * 8;
            D.24254 = D.24237 + D.24253;
            D.24255 = *D.24254;
            *D.24250 = D.24255;
            j = j + 1;
            <D.19936>:
            D.24256 = parent_interface->method.count;
            j.132 = (unsigned int) j;
            if (D.24256 > j.132) goto <D.24258>; else goto <D.19937>;
            <D.24258>:
            D.24259 = class->exception_type;
            if (D.24259 == 0) goto <D.19935>; else goto <D.19937>;
            <D.19937>:
          }
          <D.24246>:
        }
        i = i + 1;
        <D.19939>:
        D.24260 = parent->interface_offsets_count;
        D.24261 = (int) D.24260;
        if (D.24261 > i) goto <D.19938>; else goto <D.19940>;
        <D.19940>:
      }
      <D.24236>:
      <D.24234>:
      D.24262 = mono_class_need_stelemref_method (class);
      if (D.24262 != 0) goto <D.24263>; else goto <D.24264>;
      <D.24263>:
      {
        struct MonoMethod * method;

        method = mono_marshal_get_virtual_stelemref (class);
        D.24265 = method->slot;
        if (D.24265 == 0) goto <D.24266>; else goto <D.24267>;
        <D.24266>:
        D.24268 = (short int) stelemref_slot;
        method->slot = D.24268;
        goto <D.24269>;
        <D.24267>:
        D.24265 = method->slot;
        D.24270 = (int) D.24265;
        D.24271 = D.24270 != stelemref_slot;
        D.24272 = (long int) D.24271;
        D.24273 = __builtin_expect (D.24272, 0);
        if (D.24273 != 0) goto <D.24274>; else goto <D.24275>;
        <D.24274>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "class.c", 4263, "method->slot == stelemref_slot");
        <D.24275>:
        <D.24269>:
        D.24276 = (long unsigned int) stelemref_slot;
        D.24277 = D.24276 * 8;
        D.24278 = vtable + D.24277;
        *D.24278 = method;
      }
      <D.24264>:
      i = 0;
      goto <D.19945>;
      <D.19944>:
      {
        struct MonoMethod * decl;

        D.24279 = i * 2;
        D.24280 = (long unsigned int) D.24279;
        D.24281 = D.24280 * 8;
        D.24282 = overrides + D.24281;
        decl = *D.24282;
        D.24285 = decl->klass;
        D.24286 = D.24285->flags;
        D.24287 = D.24286 & 32;
        if (D.24287 != 0) goto <D.24283>; else goto <D.24288>;
        <D.24288>:
        D.24285 = decl->klass;
        D.24289 = D.24285->byval_arg.type;
        if (D.24289 == 19) goto <D.24283>; else goto <D.24290>;
        <D.24290>:
        D.24285 = decl->klass;
        D.24289 = D.24285->byval_arg.type;
        if (D.24289 == 30) goto <D.24283>; else goto <D.24284>;
        <D.24283>:
        {
          int dslot;

          dslot = mono_method_get_vtable_slot (decl);
          if (dslot == -1) goto <D.24291>; else goto <D.24292>;
          <D.24291>:
          mono_class_set_failure (class, 7, 0B);
          return;
          <D.24292>:
          D.24285 = decl->klass;
          D.24293 = mono_class_interface_offset (class, D.24285);
          dslot = D.24293 + dslot;
          D.24294 = (long unsigned int) dslot;
          D.24295 = D.24294 * 8;
          D.24296 = vtable + D.24295;
          D.24279 = i * 2;
          D.24297 = (sizetype) D.24279;
          D.24298 = D.24297 + 1;
          D.24299 = D.24298 * 8;
          D.24300 = overrides + D.24299;
          D.24301 = *D.24300;
          *D.24296 = D.24301;
          D.24294 = (long unsigned int) dslot;
          D.24295 = D.24294 * 8;
          D.24296 = vtable + D.24295;
          D.24302 = *D.24296;
          D.24303 = (short int) dslot;
          D.24302->slot = D.24303;
          if (override_map == 0B) goto <D.24304>; else goto <D.24305>;
          <D.24304>:
          override_map = monoeg_g_hash_table_new (mono_aligned_addr_hash, 0B);
          <D.24305>:
          D.24279 = i * 2;
          D.24280 = (long unsigned int) D.24279;
          D.24281 = D.24280 * 8;
          D.24282 = overrides + D.24281;
          D.24306 = *D.24282;
          D.24279 = i * 2;
          D.24297 = (sizetype) D.24279;
          D.24298 = D.24297 + 1;
          D.24299 = D.24298 * 8;
          D.24300 = overrides + D.24299;
          D.24301 = *D.24300;
          monoeg_g_hash_table_insert_replace (override_map, D.24306, D.24301, 0);
          D.24307 = mono_security_get_mode ();
          if (D.24307 == 1) goto <D.24308>; else goto <D.24309>;
          <D.24308>:
          D.24294 = (long unsigned int) dslot;
          D.24295 = D.24294 * 8;
          D.24296 = vtable + D.24295;
          D.24302 = *D.24296;
          mono_security_core_clr_check_override (class, D.24302, decl);
          <D.24309>:
        }
        <D.24284>:
      }
      i = i + 1;
      <D.19945>:
      if (i < onum) goto <D.19944>; else goto <D.19946>;
      <D.19946>:
      {
        void * iter;
        struct MonoMethod * cm;

        try
          {
            iter = 0B;
            virt_methods = 0B;
            goto <D.19950>;
            <D.19949>:
            virt_methods = monoeg_g_slist_prepend (virt_methods, cm);
            <D.19950>:
            cm = mono_class_get_virtual_methods (class, &iter);
            if (cm != 0B) goto <D.19949>; else goto <D.19951>;
            <D.19951>:
            D.24259 = class->exception_type;
            if (D.24259 != 0) goto fail; else goto <D.24310>;
            <D.24310>:
          }
        finally
          {
            iter = {CLOBBER};
          }
      }
      i = 0;
      goto <D.19980>;
      <D.19979>:
      {
        struct MonoClass * parent;
        int ic_offset;
        gboolean interface_is_explicitly_implemented_by_class;
        int im_index;

        parent = class->parent;
        D.24311 = class->interfaces_packed;
        D.24169 = (long unsigned int) i;
        D.24170 = D.24169 * 8;
        D.24312 = D.24311 + D.24170;
        ic = *D.24312;
        ic_offset = mono_class_interface_offset (class, ic);
        mono_class_setup_methods (ic);
        D.24313 = ic->exception_type;
        if (D.24313 != 0) goto fail; else goto <D.24314>;
        <D.24314>:
        if (parent != 0B) goto <D.24315>; else goto <D.24316>;
        <D.24315>:
        {
          int implemented_interfaces_index;

          interface_is_explicitly_implemented_by_class = 0;
          implemented_interfaces_index = 0;
          goto <D.19960>;
          <D.19959>:
          D.24317 = class->interfaces;
          D.24318 = (long unsigned int) implemented_interfaces_index;
          D.24319 = D.24318 * 8;
          D.24320 = D.24317 + D.24319;
          D.24321 = *D.24320;
          if (D.24321 == ic) goto <D.24322>; else goto <D.24323>;
          <D.24322>:
          interface_is_explicitly_implemented_by_class = 1;
          goto <D.19958>;
          <D.24323>:
          implemented_interfaces_index = implemented_interfaces_index + 1;
          <D.19960>:
          D.24324 = class->interface_count;
          D.24325 = (int) D.24324;
          if (D.24325 > implemented_interfaces_index) goto <D.19959>; else goto <D.19958>;
          <D.19958>:
        }
        goto <D.24326>;
        <D.24316>:
        interface_is_explicitly_implemented_by_class = 1;
        <D.24326>:
        im_index = 0;
        goto <D.19977>;
        <D.19976>:
        {
          struct MonoMethod * im;
          int im_slot;
          struct MonoMethod * override_im;

          D.24327 = ic->methods;
          D.24328 = (long unsigned int) im_index;
          D.24329 = D.24328 * 8;
          D.24330 = D.24327 + D.24329;
          im = *D.24330;
          D.24331 = im->slot;
          D.24332 = (int) D.24331;
          im_slot = D.24332 + ic_offset;
          if (override_map != 0B) goto <D.24334>; else goto <D.24335>;
          <D.24334>:
          iftmp.133 = monoeg_g_hash_table_lookup (override_map, im);
          goto <D.24336>;
          <D.24335>:
          iftmp.133 = 0B;
          <D.24336>:
          override_im = iftmp.133;
          D.24337 = im->flags;
          D.24338 = (int) D.24337;
          D.24339 = D.24338 & 16;
          if (D.24339 != 0) goto <D.24340>; else goto <D.24341>;
          <D.24340>:
          // predicted unlikely by continue predictor.
          goto <D.19964>;
          <D.24341>:
          if (override_im == 0B) goto <D.24342>; else goto <D.24343>;
          <D.24342>:
          {
            int cm_index;
            void * iter;
            struct MonoMethod * cm;

            iter = 0B;
            l = virt_methods;
            goto <D.19969>;
            <D.19968>:
            cm = l->data;
            D.24344 = (long unsigned int) im_slot;
            D.24345 = D.24344 * 8;
            D.24346 = vtable + D.24345;
            D.24347 = *D.24346;
            D.24348 = D.24347 == 0B;
            D.24349 = (int) D.24348;
            D.24350 = check_interface_method_override (class, im, cm, 1, interface_is_explicitly_implemented_by_class, D.24349, security_enabled);
            if (D.24350 != 0) goto <D.24351>; else goto <D.24352>;
            <D.24351>:
            D.24344 = (long unsigned int) im_slot;
            D.24345 = D.24344 * 8;
            D.24346 = vtable + D.24345;
            *D.24346 = cm;
            D.24353 = cm->slot;
            if (D.24353 < 0) goto <D.24354>; else goto <D.24355>;
            <D.24354>:
            D.24356 = (short int) im_slot;
            cm->slot = D.24356;
            <D.24355>:
            <D.24352>:
            D.24259 = class->exception_type;
            if (D.24259 != 0) goto fail; else goto <D.24357>;
            <D.24357>:
            l = l->next;
            <D.19969>:
            if (l != 0B) goto <D.19968>; else goto <D.19970>;
            <D.19970>:
            D.24344 = (long unsigned int) im_slot;
            D.24345 = D.24344 * 8;
            D.24346 = vtable + D.24345;
            D.24347 = *D.24346;
            if (D.24347 == 0B) goto <D.24358>; else goto <D.24359>;
            <D.24358>:
            D.24177 = class->parent;
            if (D.24177 != 0B) goto <D.24360>; else goto <D.24361>;
            <D.24360>:
            {
              struct MonoClass * parent;

              parent = class->parent;
              D.24362 = parent->vtable_size;
              cm_index = D.24362 + -1;
              goto <D.19975>;
              <D.19974>:
              {
                struct MonoMethod * cm;

                D.24363 = parent->vtable;
                D.24364 = (long unsigned int) cm_index;
                D.24365 = D.24364 * 8;
                D.24366 = D.24363 + D.24365;
                cm = *D.24366;
                if (cm != 0B) goto <D.24367>; else goto <D.24368>;
                <D.24367>:
                D.24369 = check_interface_method_override (class, im, cm, 0, 0, 1, security_enabled);
                if (D.24369 != 0) goto <D.24370>; else goto <D.24371>;
                <D.24370>:
                D.24344 = (long unsigned int) im_slot;
                D.24345 = D.24344 * 8;
                D.24346 = vtable + D.24345;
                *D.24346 = cm;
                D.24372 = cm->slot;
                if (D.24372 < 0) goto <D.24373>; else goto <D.24374>;
                <D.24373>:
                D.24356 = (short int) im_slot;
                cm->slot = D.24356;
                <D.24374>:
                goto <D.19973>;
                <D.24371>:
                <D.24368>:
                D.24259 = class->exception_type;
                if (D.24259 != 0) goto fail; else goto <D.24375>;
                <D.24375>:
              }
              cm_index = cm_index + -1;
              <D.19975>:
              if (cm_index >= 0) goto <D.19974>; else goto <D.19973>;
              <D.19973>:
            }
            <D.24361>:
            <D.24359>:
          }
          goto <D.24376>;
          <D.24343>:
          D.24344 = (long unsigned int) im_slot;
          D.24345 = D.24344 * 8;
          D.24346 = vtable + D.24345;
          D.24347 = *D.24346;
          D.24377 = D.24347 != override_im;
          D.24378 = (long int) D.24377;
          D.24379 = __builtin_expect (D.24378, 0);
          if (D.24379 != 0) goto <D.24380>; else goto <D.24381>;
          <D.24380>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "class.c", 4399, "vtable [im_slot] == override_im");
          <D.24381>:
          <D.24376>:
        }
        <D.19964>:
        im_index = im_index + 1;
        <D.19977>:
        D.24382 = ic->method.count;
        im_index.134 = (unsigned int) im_index;
        if (D.24382 > im_index.134) goto <D.19976>; else goto <D.19978>;
        <D.19978>:
      }
      i = i + 1;
      <D.19980>:
      D.24384 = class->interface_offsets_count;
      D.24385 = (int) D.24384;
      if (D.24385 > i) goto <D.19979>; else goto <D.19981>;
      <D.19981>:
      D.24386 = class->flags;
      D.24387 = D.24386 & 128;
      if (D.24387 == 0) goto <D.24388>; else goto <D.24389>;
      <D.24388>:
      i = 0;
      goto <D.19991>;
      <D.19990>:
      {
        int ic_offset;
        int im_index;

        D.24311 = class->interfaces_packed;
        D.24169 = (long unsigned int) i;
        D.24170 = D.24169 * 8;
        D.24312 = D.24311 + D.24170;
        ic = *D.24312;
        ic_offset = mono_class_interface_offset (class, ic);
        im_index = 0;
        goto <D.19988>;
        <D.19987>:
        {
          struct MonoMethod * im;
          int im_slot;

          D.24327 = ic->methods;
          D.24390 = (long unsigned int) im_index;
          D.24391 = D.24390 * 8;
          D.24392 = D.24327 + D.24391;
          im = *D.24392;
          D.24393 = im->slot;
          D.24394 = (int) D.24393;
          im_slot = D.24394 + ic_offset;
          D.24395 = im->flags;
          D.24396 = (int) D.24395;
          D.24397 = D.24396 & 16;
          if (D.24397 != 0) goto <D.24398>; else goto <D.24399>;
          <D.24398>:
          // predicted unlikely by continue predictor.
          goto <D.19986>;
          <D.24399>:
          D.24400 = (long unsigned int) im_slot;
          D.24401 = D.24400 * 8;
          D.24402 = vtable + D.24401;
          D.24403 = *D.24402;
          if (D.24403 == 0B) goto <D.24404>; else goto <D.24405>;
          <D.24404>:
          print_unimplemented_interface_method_info (class, ic, im, im_slot, overrides, onum);
          goto fail;
          <D.24405>:
        }
        <D.19986>:
        im_index = im_index + 1;
        <D.19988>:
        D.24382 = ic->method.count;
        im_index.135 = (unsigned int) im_index;
        if (D.24382 > im_index.135) goto <D.19987>; else goto <D.19989>;
        <D.19989>:
      }
      i = i + 1;
      <D.19991>:
      D.24384 = class->interface_offsets_count;
      D.24385 = (int) D.24384;
      if (D.24385 > i) goto <D.19990>; else goto <D.19992>;
      <D.19992>:
      <D.24389>:
      class_iter = 0B;
      l = virt_methods;
      goto <D.20007>;
      <D.20006>:
      cm = l->data;
      D.24407 = cm->flags;
      D.24408 = (int) D.24407;
      D.24409 = D.24408 & 256;
      if (D.24409 == 0) goto <D.24410>; else goto <D.24411>;
      <D.24410>:
      {
        int slot;

        slot = -1;
        k = class->parent;
        goto <D.20005>;
        <D.20004>:
        {
          void * k_iter;
          struct MonoMethod * m1;

          try
            {
              k_iter = 0B;
              goto <D.20002>;
              <D.20001>:
              {
                struct MonoMethodSignature * cmsig;
                struct MonoMethodSignature * m1sig;

                cmsig = mono_method_signature (cm);
                m1sig = mono_method_signature (m1);
                if (cmsig == 0B) goto <D.24412>; else goto <D.24414>;
                <D.24414>:
                if (m1sig == 0B) goto <D.24412>; else goto <D.24413>;
                <D.24412>:
                mono_class_set_failure (class, 7, 0B);
                return;
                <D.24413>:
                D.24415 = cm->name;
                D.24416 = m1->name;
                D.24417 = strcmp (D.24415, D.24416);
                if (D.24417 == 0) goto <D.24418>; else goto <D.24419>;
                <D.24418>:
                D.24420 = mono_metadata_signature_equal (cmsig, m1sig);
                if (D.24420 != 0) goto <D.24421>; else goto <D.24422>;
                <D.24421>:
                if (security_enabled != 0) goto <D.24423>; else goto <D.24424>;
                <D.24423>:
                D.24425 = m1->flags;
                D.24426 = (int) D.24425;
                D.24427 = D.24426 & 16384;
                if (D.24427 != 0) goto <D.24428>; else goto <D.24429>;
                <D.24428>:
                mono_secman_inheritancedemand_method (cm, m1);
                <D.24429>:
                <D.24424>:
                D.24430 = mono_security_get_mode ();
                if (D.24430 == 1) goto <D.24431>; else goto <D.24432>;
                <D.24431>:
                mono_security_core_clr_check_override (class, cm, m1);
                <D.24432>:
                slot = mono_method_get_vtable_slot (m1);
                if (slot == -1) goto fail; else goto <D.24433>;
                <D.24433>:
                D.24434 = is_wcf_hack_disabled ();
                if (D.24434 != 0) goto <D.24435>; else goto <D.24436>;
                <D.24435>:
                D.24437 = mono_method_can_access_method_full (cm, m1, 0B);
                if (D.24437 == 0) goto <D.24438>; else goto <D.24439>;
                <D.24438>:
                {
                  char * body_name;
                  char * decl_name;

                  body_name = mono_method_full_name (cm, 1);
                  decl_name = mono_method_full_name (m1, 1);
                  D.24440 = monoeg_g_strdup_printf ("Method %s overrides method \'%s\' which is not accessible", body_name, decl_name);
                  mono_class_set_failure (class, 7, D.24440);
                  monoeg_g_free (body_name);
                  monoeg_g_free (decl_name);
                  goto fail;
                }
                <D.24439>:
                <D.24436>:
                D.24441 = cm->slot;
                D.24442 = (int) D.24441;
                D.24443 = D.24442 >= max_vtsize;
                D.24444 = (long int) D.24443;
                D.24445 = __builtin_expect (D.24444, 0);
                if (D.24445 != 0) goto <D.24446>; else goto <D.24447>;
                <D.24446>:
                monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "class.c", 4484, "cm->slot < max_vtsize");
                <D.24447>:
                if (override_map == 0B) goto <D.24448>; else goto <D.24449>;
                <D.24448>:
                override_map = monoeg_g_hash_table_new (mono_aligned_addr_hash, 0B);
                <D.24449>:
                monoeg_g_hash_table_insert_replace (override_map, m1, cm, 0);
                goto <D.20000>;
                <D.24422>:
                <D.24419>:
              }
              <D.20002>:
              m1 = mono_class_get_virtual_methods (k, &k_iter);
              if (m1 != 0B) goto <D.20001>; else goto <D.20000>;
              <D.20000>:
              D.24450 = k->exception_type;
              if (D.24450 != 0) goto fail; else goto <D.24451>;
              <D.24451>:
              if (slot >= 0) goto <D.20003>; else goto <D.24452>;
              <D.24452>:
            }
          finally
            {
              k_iter = {CLOBBER};
            }
        }
        k = k->parent;
        <D.20005>:
        if (k != 0B) goto <D.20004>; else goto <D.20003>;
        <D.20003>:
        if (slot >= 0) goto <D.24453>; else goto <D.24454>;
        <D.24453>:
        D.24455 = (short int) slot;
        cm->slot = D.24455;
        <D.24454>:
      }
      <D.24411>:
      D.24407 = cm->flags;
      D.24456 = (unsigned int) D.24407;
      D.24457 = D.24456 & 288;
      if (D.24457 == 256) goto <D.24458>; else goto <D.24459>;
      <D.24458>:
      D.24441 = cm->slot;
      if (D.24441 >= 0) goto <D.24460>; else goto <D.24461>;
      <D.24460>:
      cm->slot = -1;
      <D.24461>:
      <D.24459>:
      D.24441 = cm->slot;
      if (D.24441 < 0) goto <D.24462>; else goto <D.24463>;
      <D.24462>:
      cur_slot.136 = cur_slot;
      cur_slot = cur_slot.136 + 1;
      D.24465 = (short int) cur_slot.136;
      cm->slot = D.24465;
      <D.24463>:
      D.24407 = cm->flags;
      D.24408 = (int) D.24407;
      D.24466 = D.24408 & 1024;
      if (D.24466 == 0) goto <D.24467>; else goto <D.24468>;
      <D.24467>:
      D.24441 = cm->slot;
      D.24469 = (long unsigned int) D.24441;
      D.24470 = D.24469 * 8;
      D.24471 = vtable + D.24470;
      *D.24471 = cm;
      <D.24468>:
      l = l->next;
      <D.20007>:
      if (l != 0B) goto <D.20006>; else goto <D.20008>;
      <D.20008>:
      i = 0;
      goto <D.20011>;
      <D.20010>:
      {
        struct MonoMethod * decl;

        D.24279 = i * 2;
        D.24280 = (long unsigned int) D.24279;
        D.24281 = D.24280 * 8;
        D.24282 = overrides + D.24281;
        decl = *D.24282;
        D.24472 = decl->klass;
        D.24473 = D.24472->flags;
        D.24474 = D.24473 & 32;
        if (D.24474 == 0) goto <D.24475>; else goto <D.24476>;
        <D.24475>:
        D.24472 = decl->klass;
        D.24477 = D.24472->byval_arg.type;
        if (D.24477 != 19) goto <D.24478>; else goto <D.24479>;
        <D.24478>:
        D.24472 = decl->klass;
        D.24477 = D.24472->byval_arg.type;
        if (D.24477 != 30) goto <D.24480>; else goto <D.24481>;
        <D.24480>:
        D.24482 = decl->slot;
        D.24483 = D.24482 == -1;
        D.24484 = (long int) D.24483;
        D.24485 = __builtin_expect (D.24484, 0);
        if (D.24485 != 0) goto <D.24486>; else goto <D.24487>;
        <D.24486>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "class.c", 4519, "decl->slot != -1");
        <D.24487>:
        D.24482 = decl->slot;
        D.24488 = (long unsigned int) D.24482;
        D.24489 = D.24488 * 8;
        D.24490 = vtable + D.24489;
        D.24279 = i * 2;
        D.24297 = (sizetype) D.24279;
        D.24298 = D.24297 + 1;
        D.24299 = D.24298 * 8;
        D.24300 = overrides + D.24299;
        D.24301 = *D.24300;
        *D.24490 = D.24301;
        D.24279 = i * 2;
        D.24297 = (sizetype) D.24279;
        D.24298 = D.24297 + 1;
        D.24299 = D.24298 * 8;
        D.24300 = overrides + D.24299;
        D.24301 = *D.24300;
        D.24482 = decl->slot;
        D.24301->slot = D.24482;
        if (override_map == 0B) goto <D.24491>; else goto <D.24492>;
        <D.24491>:
        override_map = monoeg_g_hash_table_new (mono_aligned_addr_hash, 0B);
        <D.24492>:
        D.24279 = i * 2;
        D.24297 = (sizetype) D.24279;
        D.24298 = D.24297 + 1;
        D.24299 = D.24298 * 8;
        D.24300 = overrides + D.24299;
        D.24301 = *D.24300;
        monoeg_g_hash_table_insert_replace (override_map, decl, D.24301, 0);
        D.24493 = mono_security_get_mode ();
        if (D.24493 == 1) goto <D.24494>; else goto <D.24495>;
        <D.24494>:
        D.24482 = decl->slot;
        D.24488 = (long unsigned int) D.24482;
        D.24489 = D.24488 * 8;
        D.24490 = vtable + D.24489;
        D.24496 = *D.24490;
        mono_security_core_clr_check_override (class, D.24496, decl);
        <D.24495>:
        <D.24481>:
        <D.24479>:
        <D.24476>:
      }
      i = i + 1;
      <D.20011>:
      if (i < onum) goto <D.20010>; else goto <D.20012>;
      <D.20012>:
      if (override_map != 0B) goto <D.24497>; else goto <D.24498>;
      <D.24497>:
      {
        struct MonoMethod * cm;

        i = 0;
        goto <D.20015>;
        <D.20014>:
        D.24169 = (long unsigned int) i;
        D.24170 = D.24169 * 8;
        D.24499 = vtable + D.24170;
        D.24500 = *D.24499;
        if (D.24500 != 0B) goto <D.24501>; else goto <D.24502>;
        <D.24501>:
        D.24169 = (long unsigned int) i;
        D.24170 = D.24169 * 8;
        D.24499 = vtable + D.24170;
        D.24500 = *D.24499;
        cm = monoeg_g_hash_table_lookup (override_map, D.24500);
        if (cm != 0B) goto <D.24503>; else goto <D.24504>;
        <D.24503>:
        D.24169 = (long unsigned int) i;
        D.24170 = D.24169 * 8;
        D.24499 = vtable + D.24170;
        *D.24499 = cm;
        <D.24504>:
        <D.24502>:
        i = i + 1;
        <D.20015>:
        if (i < max_vtsize) goto <D.20014>; else goto <D.20016>;
        <D.20016>:
        monoeg_g_hash_table_destroy (override_map);
        override_map = 0B;
      }
      <D.24498>:
      monoeg_g_slist_free (virt_methods);
      virt_methods = 0B;
      D.24386 = class->flags;
      D.24387 = D.24386 & 128;
      if (D.24387 == 0) goto <D.24505>; else goto <D.24506>;
      <D.24505>:
      i = 0;
      goto <D.20020>;
      <D.20019>:
      D.24169 = (long unsigned int) i;
      D.24170 = D.24169 * 8;
      D.24499 = vtable + D.24170;
      D.24500 = *D.24499;
      if (D.24500 == 0B) goto <D.24507>; else goto <D.24509>;
      <D.24509>:
      D.24169 = (long unsigned int) i;
      D.24170 = D.24169 * 8;
      D.24499 = vtable + D.24170;
      D.24500 = *D.24499;
      D.24510 = D.24500->flags;
      D.24511 = (int) D.24510;
      D.24512 = D.24511 & 1040;
      if (D.24512 != 0) goto <D.24507>; else goto <D.24508>;
      <D.24507>:
      {
        char * type_name;
        char * method_name;

        type_name = mono_type_get_full_name (class);
        D.24169 = (long unsigned int) i;
        D.24170 = D.24169 * 8;
        D.24499 = vtable + D.24170;
        D.24500 = *D.24499;
        if (D.24500 != 0B) goto <D.24514>; else goto <D.24515>;
        <D.24514>:
        D.24169 = (long unsigned int) i;
        D.24170 = D.24169 * 8;
        D.24499 = vtable + D.24170;
        D.24500 = *D.24499;
        iftmp.137 = mono_method_full_name (D.24500, 1);
        goto <D.24516>;
        <D.24515>:
        iftmp.137 = monoeg_strdup ("none");
        <D.24516>:
        method_name = iftmp.137;
        D.24517 = monoeg_g_strdup_printf ("Type %s has invalid vtable method slot %d with method %s", type_name, i, method_name);
        mono_class_set_failure (class, 7, D.24517);
        monoeg_g_free (type_name);
        monoeg_g_free (method_name);
        return;
      }
      <D.24508>:
      i = i + 1;
      <D.20020>:
      if (i < cur_slot) goto <D.20019>; else goto <D.20021>;
      <D.20021>:
      <D.24506>:
      D.24195 = class->generic_class;
      if (D.24195 != 0B) goto <D.24518>; else goto <D.24519>;
      <D.24518>:
      {
        struct MonoClass * gklass;

        D.24195 = class->generic_class;
        gklass = D.24195->container_class;
        mono_class_init (gklass);
        D.24520 = gklass->vtable_size;
        D.24521 = MAX_EXPR <D.24520, cur_slot>;
        class->vtable_size = D.24521;
      }
      goto <D.24522>;
      <D.24519>:
      D.24523 = class->vtable_size;
      if (D.24523 != 0) goto <D.24524>; else goto <D.24525>;
      <D.24524>:
      D.24523 = class->vtable_size;
      D.24526 = D.24523 != cur_slot;
      D.24527 = (long int) D.24526;
      D.24528 = __builtin_expect (D.24527, 0);
      if (D.24528 != 0) goto <D.24529>; else goto <D.24530>;
      <D.24529>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "class.c", 4580, "cur_slot == class->vtable_size");
      <D.24530>:
      <D.24525>:
      class->vtable_size = cur_slot;
      <D.24522>:
      D.24177 = class->parent;
      if (D.24177 != 0B) goto <D.24533>; else goto <D.24531>;
      <D.24533>:
      D.24177 = class->parent;
      D.24184 = D.24177->vtable_size;
      D.24523 = class->vtable_size;
      if (D.24184 == D.24523) goto <D.24534>; else goto <D.24531>;
      <D.24534>:
      D.24177 = class->parent;
      D.24535 = D.24177->vtable;
      D.24523 = class->vtable_size;
      D.24536 = (long unsigned int) D.24523;
      D.24537 = D.24536 * 8;
      D.24538 = memcmp (D.24535, vtable, D.24537);
      if (D.24538 == 0) goto <D.24539>; else goto <D.24531>;
      <D.24539>:
      mono_memory_barrier ();
      D.24177 = class->parent;
      D.24535 = D.24177->vtable;
      class->vtable = D.24535;
      goto <D.24532>;
      <D.24531>:
      {
        struct MonoMethod * * tmp;

        D.24523 = class->vtable_size;
        D.24540 = (unsigned int) D.24523;
        D.24541 = D.24540 * 8;
        D.24542 = (int) D.24541;
        tmp = mono_class_alloc0 (class, D.24542);
        D.24523 = class->vtable_size;
        D.24536 = (long unsigned int) D.24523;
        D.24537 = D.24536 * 8;
        memcpy (tmp, vtable, D.24537);
        mono_memory_barrier ();
        class->vtable = tmp;
      }
      <D.24532>:
      mono_print_vtable.138 = mono_print_vtable;
      if (mono_print_vtable.138 != 0) goto <D.24544>; else goto <D.24545>;
      <D.24544>:
      {
        int icount;

        icount = 0;
        print_implemented_interfaces (class);
        i = 0;
        goto <D.20026>;
        <D.20025>:
        D.24194 = class->max_interface_id;
        D.24546 = (int) D.24194;
        if (D.24546 >= i) goto <D.24547>; else goto <D.24548>;
        <D.24547>:
        D.24549 = class->interface_bitmap;
        D.24550 = i >> 3;
        D.24551 = (sizetype) D.24550;
        D.24552 = D.24549 + D.24551;
        D.24553 = *D.24552;
        D.24554 = (int) D.24553;
        D.24555 = i & 7;
        D.24556 = D.24554 >> D.24555;
        D.24557 = D.24556 & 1;
        if (D.24557 != 0) goto <D.24558>; else goto <D.24559>;
        <D.24558>:
        icount = icount + 1;
        <D.24559>:
        <D.24548>:
        i = i + 1;
        <D.20026>:
        if (i <= max_iid) goto <D.20025>; else goto <D.20027>;
        <D.20027>:
        D.24560 = &class->byval_arg;
        D.24561 = mono_type_full_name (D.24560);
        D.24523 = class->vtable_size;
        printf ("VTable %s (vtable entries = %d, interfaces = %d)\n", D.24561, D.24523, icount);
        i = 0;
        goto <D.20030>;
        <D.20029>:
        {
          struct MonoMethod * cm;

          D.24169 = (long unsigned int) i;
          D.24170 = D.24169 * 8;
          D.24499 = vtable + D.24170;
          cm = *D.24499;
          if (cm != 0B) goto <D.24562>; else goto <D.24563>;
          <D.24562>:
          D.24564 = cm->slot;
          D.24565 = (int) D.24564;
          D.24566 = mono_method_full_name (cm, 1);
          printf ("  slot assigned: %03d, slot index: %03d %s\n", i, D.24565, D.24566);
          <D.24563>:
        }
        i = i + 1;
        <D.20030>:
        if (i < cur_slot) goto <D.20029>; else goto <D.20031>;
        <D.20031>:
        if (icount != 0) goto <D.24567>; else goto <D.24568>;
        <D.24567>:
        D.24569 = class->name_space;
        D.24570 = class->name;
        printf ("Interfaces %s.%s (max_iid = %d)\n", D.24569, D.24570, max_iid);
        i = 0;
        goto <D.20033>;
        <D.20032>:
        D.24317 = class->interfaces;
        D.24169 = (long unsigned int) i;
        D.24170 = D.24169 * 8;
        D.24571 = D.24317 + D.24170;
        ic = *D.24571;
        D.24572 = mono_class_interface_offset (class, ic);
        D.24573 = count_virtual_methods (ic);
        D.24574 = ic->interface_id;
        D.24575 = (int) D.24574;
        D.24576 = &ic->byval_arg;
        D.24577 = mono_type_full_name (D.24576);
        printf ("  slot offset: %03d, method count: %03d, iid: %03d %s\n", D.24572, D.24573, D.24575, D.24577);
        i = i + 1;
        <D.20033>:
        D.24324 = class->interface_count;
        D.24325 = (int) D.24324;
        if (D.24325 > i) goto <D.20032>; else goto <D.20034>;
        <D.20034>:
        k = class->parent;
        goto <D.20039>;
        <D.20038>:
        i = 0;
        goto <D.20036>;
        <D.20035>:
        D.24578 = k->interfaces;
        D.24169 = (long unsigned int) i;
        D.24170 = D.24169 * 8;
        D.24579 = D.24578 + D.24170;
        ic = *D.24579;
        D.24580 = mono_class_interface_offset (class, ic);
        D.24581 = count_virtual_methods (ic);
        D.24574 = ic->interface_id;
        D.24575 = (int) D.24574;
        D.24576 = &ic->byval_arg;
        D.24582 = mono_type_full_name (D.24576);
        printf ("  parent slot offset: %03d, method count: %03d, iid: %03d %s\n", D.24580, D.24581, D.24575, D.24582);
        i = i + 1;
        <D.20036>:
        D.24583 = k->interface_count;
        D.24584 = (int) D.24583;
        if (D.24584 > i) goto <D.20035>; else goto <D.20037>;
        <D.20037>:
        k = k->parent;
        <D.20039>:
        if (k != 0B) goto <D.20038>; else goto <D.20040>;
        <D.20040>:
        <D.24568>:
      }
      <D.24545>:
      return;
      fail:
      {
        char * name;

        name = mono_type_get_full_name (class);
        D.24585 = monoeg_g_strdup_printf ("VTable setup of type %s failed", name);
        mono_class_set_failure (class, 7, D.24585);
        monoeg_g_free (name);
        if (override_map != 0B) goto <D.24586>; else goto <D.24587>;
        <D.24586>:
        monoeg_g_hash_table_destroy (override_map);
        <D.24587>:
        if (virt_methods != 0B) goto <D.24588>; else goto <D.24589>;
        <D.24588>:
        monoeg_g_slist_free (virt_methods);
        <D.24589>:
      }
    }
  finally
    {
      error = {CLOBBER};
    }
}


verify_class_overrides (struct MonoClass * class, struct MonoMethod * * overrides, int onum)
{
  int D.24600;
  long unsigned int D.24601;
  long unsigned int D.24602;
  struct MonoMethod * * D.24603;
  sizetype D.24604;
  sizetype D.24605;
  sizetype D.24606;
  struct MonoMethod * * D.24607;
  struct MonoClass * D.24608;
  struct MonoClass * D.24609;
  struct MonoClass * D.24610;
  gchar * D.24613;
  gboolean D.24614;
  short unsigned int D.24615;
  unsigned int D.24616;
  unsigned int D.24617;
  int D.24620;
  int D.24621;
  gchar * D.24624;
  gchar * D.24626;
  short unsigned int D.24627;
  unsigned int D.24628;
  unsigned int D.24629;
  gchar * D.24634;
  gchar * D.24636;
  struct MonoClass * D.24637;
  int D.24638;
  gchar * D.24641;
  int D.24642;
  int D.24645;
  gchar * D.24648;
  int i;

  i = 0;
  goto <D.19885>;
  <D.19884>:
  {
    struct MonoMethod * decl;
    struct MonoMethod * body;

    D.24600 = i * 2;
    D.24601 = (long unsigned int) D.24600;
    D.24602 = D.24601 * 8;
    D.24603 = overrides + D.24602;
    decl = *D.24603;
    D.24600 = i * 2;
    D.24604 = (sizetype) D.24600;
    D.24605 = D.24604 + 1;
    D.24606 = D.24605 * 8;
    D.24607 = overrides + D.24606;
    body = *D.24607;
    D.24608 = body->klass;
    D.24609 = mono_class_get_generic_type_definition (D.24608);
    D.24610 = mono_class_get_generic_type_definition (class);
    if (D.24609 != D.24610) goto <D.24611>; else goto <D.24612>;
    <D.24611>:
    D.24613 = monoeg_strdup ("Method belongs to a different class than the declared one");
    mono_class_set_failure (class, 7, D.24613);
    D.24614 = 0;
    return D.24614;
    <D.24612>:
    D.24615 = body->flags;
    D.24616 = (unsigned int) D.24615;
    D.24617 = D.24616 & 80;
    if (D.24617 != 64) goto <D.24618>; else goto <D.24619>;
    <D.24618>:
    D.24615 = body->flags;
    D.24620 = (int) D.24615;
    D.24621 = D.24620 & 16;
    if (D.24621 != 0) goto <D.24622>; else goto <D.24623>;
    <D.24622>:
    D.24624 = monoeg_strdup ("Method must not be static to override a base type");
    mono_class_set_failure (class, 7, D.24624);
    goto <D.24625>;
    <D.24623>:
    D.24626 = monoeg_strdup ("Method must be virtual to override a base type");
    mono_class_set_failure (class, 7, D.24626);
    <D.24625>:
    D.24614 = 0;
    return D.24614;
    <D.24619>:
    D.24627 = decl->flags;
    D.24628 = (unsigned int) D.24627;
    D.24629 = D.24628 & 80;
    if (D.24629 != 64) goto <D.24630>; else goto <D.24631>;
    <D.24630>:
    D.24615 = body->flags;
    D.24620 = (int) D.24615;
    D.24621 = D.24620 & 16;
    if (D.24621 != 0) goto <D.24632>; else goto <D.24633>;
    <D.24632>:
    D.24634 = monoeg_strdup ("Cannot override a static method in a base type");
    mono_class_set_failure (class, 7, D.24634);
    goto <D.24635>;
    <D.24633>:
    D.24636 = monoeg_strdup ("Cannot override a non virtual method in a base type");
    mono_class_set_failure (class, 7, D.24636);
    <D.24635>:
    D.24614 = 0;
    return D.24614;
    <D.24631>:
    D.24637 = decl->klass;
    D.24638 = mono_class_is_assignable_from_slow (D.24637, class);
    if (D.24638 == 0) goto <D.24639>; else goto <D.24640>;
    <D.24639>:
    D.24641 = monoeg_strdup ("Method overrides a class or interface that extended or implemented by this type");
    mono_class_set_failure (class, 7, D.24641);
    D.24614 = 0;
    return D.24614;
    <D.24640>:
    body = mono_method_get_method_definition (body);
    decl = mono_method_get_method_definition (decl);
    D.24642 = is_wcf_hack_disabled ();
    if (D.24642 != 0) goto <D.24643>; else goto <D.24644>;
    <D.24643>:
    D.24645 = mono_method_can_access_method_full (body, decl, 0B);
    if (D.24645 == 0) goto <D.24646>; else goto <D.24647>;
    <D.24646>:
    {
      char * body_name;
      char * decl_name;

      body_name = mono_method_full_name (body, 1);
      decl_name = mono_method_full_name (decl, 1);
      D.24648 = monoeg_g_strdup_printf ("Method %s overrides method \'%s\' which is not accessible", body_name, decl_name);
      mono_class_set_failure (class, 7, D.24648);
      monoeg_g_free (body_name);
      monoeg_g_free (decl_name);
      D.24614 = 0;
      return D.24614;
    }
    <D.24647>:
    <D.24644>:
  }
  i = i + 1;
  <D.19885>:
  if (i < onum) goto <D.19884>; else goto <D.19886>;
  <D.19886>:
  D.24614 = 1;
  return D.24614;
}


mono_method_get_method_definition (struct MonoMethod * method)
{
  long unsigned int D.24650;
  long unsigned int D.24651;
  struct MonoMethod * D.24652;

  goto <D.19872>;
  <D.19871>:
  method = MEM[(struct MonoMethodInflated *)method].declaring;
  <D.19872>:
  D.24650 = BIT_FIELD_REF <*method, 64, 256>;
  D.24651 = D.24650 & 2251799813685248;
  if (D.24651 != 0) goto <D.19871>; else goto <D.19873>;
  <D.19873>:
  D.24652 = method;
  return D.24652;
}


mono_class_need_stelemref_method (struct MonoClass * class)
{
  gboolean D.24654;
  int iftmp.139;
  unsigned char D.24658;
  struct MonoClass * D.24660;
  struct MonoType * D.24661;
  int D.24662;

  D.24658 = class->rank;
  if (D.24658 == 1) goto <D.24659>; else goto <D.24656>;
  <D.24659>:
  D.24660 = class->element_class;
  D.24661 = &D.24660->byval_arg;
  D.24662 = mono_type_is_reference (D.24661);
  if (D.24662 != 0) goto <D.24663>; else goto <D.24656>;
  <D.24663>:
  iftmp.139 = 1;
  goto <D.24657>;
  <D.24656>:
  iftmp.139 = 0;
  <D.24657>:
  D.24654 = iftmp.139;
  return D.24654;
}


check_interface_method_override (struct MonoClass * class, struct MonoMethod * im, struct MonoMethod * cm, gboolean require_newslot, gboolean interface_is_explicitly_implemented_by_class, gboolean slot_is_empty, gboolean security_enabled)
{
  const char * D.24665;
  const char * D.24666;
  int D.24667;
  short unsigned int D.24670;
  int D.24671;
  int D.24672;
  gboolean D.24675;
  int D.24682;
  gchar * D.24689;
  int D.24690;
  short unsigned int D.24695;
  int D.24696;
  int D.24697;
  <unnamed type> D.24700;
  int D.24703;
  int D.24706;
  gchar * D.24709;
  struct MonoClass * D.24712;
  unsigned char D.24713;
  gchar * D.24719;
  int D.24720;
  struct MonoImage * D.24723;
  struct MonoImage * D.24724;
  int D.24730;
  int D.24734;
  int D.24736;
  int D.24738;
  int D.24740;
  int D.24742;
  long unsigned int D.24745;
  char D.24746;
  char * D.24749;
  long unsigned int D.24752;
  int D.24755;
  <unnamed type> D.24762;
  int D.24765;
  int D.24768;
  gchar * D.24771;
  struct MonoMethodSignature * cmsig;
  struct MonoMethodSignature * imsig;

  D.24665 = im->name;
  D.24666 = cm->name;
  D.24667 = strcmp (D.24665, D.24666);
  if (D.24667 == 0) goto <D.24668>; else goto <D.24669>;
  <D.24668>:
  D.24670 = cm->flags;
  D.24671 = (int) D.24670;
  D.24672 = D.24671 & 6;
  if (D.24672 == 0) goto <D.24673>; else goto <D.24674>;
  <D.24673>:
  D.24675 = 0;
  return D.24675;
  <D.24674>:
  if (slot_is_empty == 0) goto <D.24676>; else goto <D.24677>;
  <D.24676>:
  if (require_newslot != 0) goto <D.24678>; else goto <D.24679>;
  <D.24678>:
  if (interface_is_explicitly_implemented_by_class == 0) goto <D.24680>; else goto <D.24681>;
  <D.24680>:
  D.24675 = 0;
  return D.24675;
  <D.24681>:
  D.24670 = cm->flags;
  D.24671 = (int) D.24670;
  D.24682 = D.24671 & 256;
  if (D.24682 == 0) goto <D.24683>; else goto <D.24684>;
  <D.24683>:
  D.24675 = 0;
  return D.24675;
  <D.24684>:
  goto <D.24685>;
  <D.24679>:
  <D.24685>:
  <D.24677>:
  cmsig = mono_method_signature (cm);
  imsig = mono_method_signature (im);
  if (cmsig == 0B) goto <D.24686>; else goto <D.24688>;
  <D.24688>:
  if (imsig == 0B) goto <D.24686>; else goto <D.24687>;
  <D.24686>:
  D.24689 = monoeg_strdup ("Could not resolve the signature of a virtual method");
  mono_class_set_failure (class, 7, D.24689);
  D.24675 = 0;
  return D.24675;
  <D.24687>:
  D.24690 = mono_metadata_signature_equal (cmsig, imsig);
  if (D.24690 == 0) goto <D.24691>; else goto <D.24692>;
  <D.24691>:
  D.24675 = 0;
  return D.24675;
  <D.24692>:
  if (security_enabled != 0) goto <D.24693>; else goto <D.24694>;
  <D.24693>:
  D.24695 = im->flags;
  D.24696 = (int) D.24695;
  D.24697 = D.24696 & 16384;
  if (D.24697 != 0) goto <D.24698>; else goto <D.24699>;
  <D.24698>:
  mono_secman_inheritancedemand_method (cm, im);
  <D.24699>:
  <D.24694>:
  D.24700 = mono_security_get_mode ();
  if (D.24700 == 1) goto <D.24701>; else goto <D.24702>;
  <D.24701>:
  mono_security_core_clr_check_override (class, cm, im);
  <D.24702>:
  D.24703 = is_wcf_hack_disabled ();
  if (D.24703 != 0) goto <D.24704>; else goto <D.24705>;
  <D.24704>:
  D.24706 = mono_method_can_access_method_full (cm, im, 0B);
  if (D.24706 == 0) goto <D.24707>; else goto <D.24708>;
  <D.24707>:
  {
    char * body_name;
    char * decl_name;

    body_name = mono_method_full_name (cm, 1);
    decl_name = mono_method_full_name (im, 1);
    D.24709 = monoeg_g_strdup_printf ("Method %s overrides method \'%s\' which is not accessible", body_name, decl_name);
    mono_class_set_failure (class, 7, D.24709);
    monoeg_g_free (body_name);
    monoeg_g_free (decl_name);
    D.24675 = 0;
    return D.24675;
  }
  <D.24708>:
  <D.24705>:
  D.24675 = 1;
  return D.24675;
  <D.24669>:
  {
    struct MonoClass * ic;
    const char * ic_name_space;
    const char * ic_name;
    char * subname;

    ic = im->klass;
    ic_name_space = ic->name_space;
    ic_name = ic->name;
    if (require_newslot == 0) goto <D.24710>; else goto <D.24711>;
    <D.24710>:
    D.24675 = 0;
    return D.24675;
    <D.24711>:
    D.24712 = cm->klass;
    D.24713 = D.24712->rank;
    if (D.24713 == 0) goto <D.24714>; else goto <D.24715>;
    <D.24714>:
    D.24675 = 0;
    return D.24675;
    <D.24715>:
    cmsig = mono_method_signature (cm);
    imsig = mono_method_signature (im);
    if (cmsig == 0B) goto <D.24716>; else goto <D.24718>;
    <D.24718>:
    if (imsig == 0B) goto <D.24716>; else goto <D.24717>;
    <D.24716>:
    D.24719 = monoeg_strdup ("Could not resolve the signature of a virtual method");
    mono_class_set_failure (class, 7, D.24719);
    D.24675 = 0;
    return D.24675;
    <D.24717>:
    D.24720 = mono_metadata_signature_equal (cmsig, imsig);
    if (D.24720 == 0) goto <D.24721>; else goto <D.24722>;
    <D.24721>:
    D.24675 = 0;
    return D.24675;
    <D.24722>:
    D.24723 = mono_class_get_image (ic);
    D.24724 = mono_defaults.corlib;
    if (D.24723 != D.24724) goto <D.24725>; else goto <D.24726>;
    <D.24725>:
    D.24675 = 0;
    return D.24675;
    <D.24726>:
    if (ic_name_space == 0B) goto <D.24727>; else goto <D.24729>;
    <D.24729>:
    D.24730 = strcmp (ic_name_space, "System.Collections.Generic");
    if (D.24730 != 0) goto <D.24727>; else goto <D.24728>;
    <D.24727>:
    D.24675 = 0;
    return D.24675;
    <D.24728>:
    if (ic_name == 0B) goto <D.24731>; else goto <D.24733>;
    <D.24733>:
    D.24734 = strcmp (ic_name, "IEnumerable`1");
    if (D.24734 != 0) goto <D.24735>; else goto <D.24732>;
    <D.24735>:
    D.24736 = strcmp (ic_name, "ICollection`1");
    if (D.24736 != 0) goto <D.24737>; else goto <D.24732>;
    <D.24737>:
    D.24738 = strcmp (ic_name, "IList`1");
    if (D.24738 != 0) goto <D.24739>; else goto <D.24732>;
    <D.24739>:
    D.24740 = strcmp (ic_name, "IReadOnlyList`1");
    if (D.24740 != 0) goto <D.24741>; else goto <D.24732>;
    <D.24741>:
    D.24742 = strcmp (ic_name, "IReadOnlyCollection`1");
    if (D.24742 != 0) goto <D.24731>; else goto <D.24732>;
    <D.24731>:
    D.24675 = 0;
    return D.24675;
    <D.24732>:
    D.24666 = cm->name;
    subname = strstr (D.24666, ic_name_space);
    D.24666 = cm->name;
    if (D.24666 != subname) goto <D.24743>; else goto <D.24744>;
    <D.24743>:
    D.24675 = 0;
    return D.24675;
    <D.24744>:
    D.24745 = __strlen_g (ic_name_space);
    subname = subname + D.24745;
    D.24746 = *subname;
    if (D.24746 != 46) goto <D.24747>; else goto <D.24748>;
    <D.24747>:
    D.24675 = 0;
    return D.24675;
    <D.24748>:
    subname = subname + 1;
    D.24749 = strstr (subname, ic_name);
    if (D.24749 != subname) goto <D.24750>; else goto <D.24751>;
    <D.24750>:
    D.24675 = 0;
    return D.24675;
    <D.24751>:
    D.24752 = __strlen_g (ic_name);
    subname = subname + D.24752;
    D.24746 = *subname;
    if (D.24746 != 46) goto <D.24753>; else goto <D.24754>;
    <D.24753>:
    D.24675 = 0;
    return D.24675;
    <D.24754>:
    subname = subname + 1;
    D.24665 = im->name;
    D.24755 = strcmp (subname, D.24665);
    if (D.24755 != 0) goto <D.24756>; else goto <D.24757>;
    <D.24756>:
    D.24675 = 0;
    return D.24675;
    <D.24757>:
    if (security_enabled != 0) goto <D.24758>; else goto <D.24759>;
    <D.24758>:
    D.24695 = im->flags;
    D.24696 = (int) D.24695;
    D.24697 = D.24696 & 16384;
    if (D.24697 != 0) goto <D.24760>; else goto <D.24761>;
    <D.24760>:
    mono_secman_inheritancedemand_method (cm, im);
    <D.24761>:
    <D.24759>:
    D.24762 = mono_security_get_mode ();
    if (D.24762 == 1) goto <D.24763>; else goto <D.24764>;
    <D.24763>:
    mono_security_core_clr_check_override (class, cm, im);
    <D.24764>:
    D.24765 = is_wcf_hack_disabled ();
    if (D.24765 != 0) goto <D.24766>; else goto <D.24767>;
    <D.24766>:
    D.24768 = mono_method_can_access_method_full (cm, im, 0B);
    if (D.24768 == 0) goto <D.24769>; else goto <D.24770>;
    <D.24769>:
    {
      char * body_name;
      char * decl_name;

      body_name = mono_method_full_name (cm, 1);
      decl_name = mono_method_full_name (im, 1);
      D.24771 = monoeg_g_strdup_printf ("Method %s overrides method \'%s\' which is not accessible", body_name, decl_name);
      mono_class_set_failure (class, 7, D.24771);
      monoeg_g_free (body_name);
      monoeg_g_free (decl_name);
      D.24675 = 0;
      return D.24675;
    }
    <D.24770>:
    <D.24767>:
    D.24675 = 1;
    return D.24675;
  }
}


print_unimplemented_interface_method_info (struct MonoClass * class, struct MonoClass * ic, struct MonoMethod * im, int im_slot, struct MonoMethod * * overrides, int onum)
{
  int D.24773;
  sizetype D.24774;
  sizetype D.24775;
  sizetype D.24776;
  struct MonoMethod * * D.24777;
  struct MonoMethod * D.24778;
  const char * D.24779;
  short int D.24780;
  int D.24781;
  long unsigned int D.24782;
  long unsigned int D.24783;
  struct MonoMethod * * D.24784;
  struct MonoMethod * D.24785;
  const char * D.24786;
  short int D.24787;
  int D.24788;
  struct MonoMethodSignature * D.24789;
  struct MonoType * D.24790;
  struct MonoType * D.24791;
  char * D.24792;
  const char * D.24793;
  unsigned char D.24794;
  struct MonoMethod * * D.24797;
  long unsigned int D.24798;
  long unsigned int D.24799;
  struct MonoMethod * * D.24800;
  struct MonoMethodSignature * D.24801;
  const char * D.24802;
  unsigned int D.24803;
  unsigned int index.140;
  int index;
  char * method_signature;
  char * type_name;

  index = 0;
  goto <D.19861>;
  <D.19860>:
  D.24773 = index * 2;
  D.24774 = (sizetype) D.24773;
  D.24775 = D.24774 + 1;
  D.24776 = D.24775 * 8;
  D.24777 = overrides + D.24776;
  D.24778 = *D.24777;
  D.24779 = D.24778->name;
  D.24773 = index * 2;
  D.24774 = (sizetype) D.24773;
  D.24775 = D.24774 + 1;
  D.24776 = D.24775 * 8;
  D.24777 = overrides + D.24776;
  D.24778 = *D.24777;
  D.24780 = D.24778->slot;
  D.24781 = (int) D.24780;
  D.24773 = index * 2;
  D.24782 = (long unsigned int) D.24773;
  D.24783 = D.24782 * 8;
  D.24784 = overrides + D.24783;
  D.24785 = *D.24784;
  D.24786 = D.24785->name;
  D.24773 = index * 2;
  D.24782 = (long unsigned int) D.24773;
  D.24783 = D.24782 * 8;
  D.24784 = overrides + D.24783;
  D.24785 = *D.24784;
  D.24787 = D.24785->slot;
  D.24788 = (int) D.24787;
  mono_trace (16, 2, " at slot %d: %s (%d) overrides %s (%d)\n", im_slot, D.24779, D.24781, D.24786, D.24788);
  index = index + 1;
  <D.19861>:
  if (index < onum) goto <D.19860>; else goto <D.19862>;
  <D.19862>:
  D.24789 = mono_method_signature (im);
  method_signature = mono_signature_get_desc (D.24789, 0);
  D.24790 = &class->byval_arg;
  type_name = mono_type_full_name (D.24790);
  D.24791 = &ic->byval_arg;
  D.24792 = mono_type_get_name (D.24791);
  D.24793 = im->name;
  mono_trace (16, 2, "no implementation for interface method %s::%s(%s) in class %s\n", D.24792, D.24793, method_signature, type_name);
  monoeg_g_free (method_signature);
  monoeg_g_free (type_name);
  mono_class_setup_methods (class);
  D.24794 = class->exception_type;
  if (D.24794 != 0) goto <D.24795>; else goto <D.24796>;
  <D.24795>:
  {
    char * name;

    name = mono_type_get_full_name (class);
    mono_trace (16, 2, "CLASS %s failed to resolve methods\n", name);
    monoeg_g_free (name);
    return;
  }
  <D.24796>:
  index = 0;
  goto <D.19866>;
  <D.19865>:
  {
    struct MonoMethod * cm;

    D.24797 = class->methods;
    D.24798 = (long unsigned int) index;
    D.24799 = D.24798 * 8;
    D.24800 = D.24797 + D.24799;
    cm = *D.24800;
    D.24801 = mono_method_signature (cm);
    method_signature = mono_signature_get_desc (D.24801, 1);
    D.24802 = cm->name;
    mono_trace (16, 2, "METHOD %s(%s)\n", D.24802, method_signature);
    monoeg_g_free (method_signature);
  }
  index = index + 1;
  <D.19866>:
  D.24803 = class->method.count;
  index.140 = (unsigned int) index;
  if (D.24803 > index.140) goto <D.19865>; else goto <D.19867>;
  <D.19867>:
}


is_wcf_hack_disabled ()
{
  int inited.141;
  const gchar * D.24809;
  _Bool D.24810;
  int disabled.142;
  gboolean D.24812;
  static gboolean disabled;
  static gboolean inited = 0;

  inited.141 = inited;
  if (inited.141 == 0) goto <D.24807>; else goto <D.24808>;
  <D.24807>:
  D.24809 = monoeg_g_getenv ("MONO_DISABLE_WCF_HACK");
  D.24810 = D.24809 != 0B;
  disabled.142 = (int) D.24810;
  disabled = disabled.142;
  inited = 1;
  <D.24808>:
  D.24812 = disabled;
  return D.24812;
}


mono_class_get_virtual_methods (struct MonoClass * klass, void * * iter)
{
  struct MonoMethod * D.24816;
  struct MonoMethod * * D.24819;
  unsigned int D.24821;
  struct MonoImage * D.24823;
  long unsigned int D.24824;
  long unsigned int D.24825;
  struct MonoGenericClass * D.24827;
  void * D.24828;
  struct MonoMethod * D.24834;
  short unsigned int D.24837;
  int D.24838;
  int D.24839;
  unsigned int D.24841;
  long unsigned int D.24842;
  long unsigned int D.24843;
  struct MonoMethod * * D.24844;
  long int D.24850;
  unsigned int D.24851;
  unsigned int i.143;
  unsigned int D.24853;
  int D.24854;
  unsigned int D.24855;
  unsigned int D.24859;
  unsigned int D.24860;
  int D.24861;
  long unsigned int D.24862;
  void * D.24863;
  struct MonoMethod * * method;

  if (iter == 0B) goto <D.24814>; else goto <D.24815>;
  <D.24814>:
  D.24816 = 0B;
  return D.24816;
  <D.24815>:
  D.24819 = klass->methods;
  if (D.24819 != 0B) goto <D.24817>; else goto <D.24820>;
  <D.24820>:
  D.24821 = klass->type_token;
  if (D.24821 == 0) goto <D.24817>; else goto <D.24822>;
  <D.24822>:
  D.24823 = klass->image;
  D.24824 = BIT_FIELD_REF <*D.24823, 64, 192>;
  D.24825 = D.24824 & 268435456;
  if (D.24825 != 0) goto <D.24817>; else goto <D.24826>;
  <D.24826>:
  D.24827 = klass->generic_class;
  if (D.24827 != 0B) goto <D.24817>; else goto <D.24818>;
  <D.24817>:
  D.24828 = *iter;
  if (D.24828 == 0B) goto <D.24829>; else goto <D.24830>;
  <D.24829>:
  mono_class_setup_methods (klass);
  D.24819 = klass->methods;
  if (D.24819 == 0B) goto <D.24831>; else goto <D.24832>;
  <D.24831>:
  D.24816 = 0B;
  return D.24816;
  <D.24832>:
  method = klass->methods;
  goto <D.24833>;
  <D.24830>:
  method = *iter;
  method = method + 8;
  <D.24833>:
  goto <D.20996>;
  <D.20995>:
  D.24834 = *method;
  if (D.24834 != 0B) goto <D.24835>; else goto <D.24836>;
  <D.24835>:
  D.24834 = *method;
  D.24837 = D.24834->flags;
  D.24838 = (int) D.24837;
  D.24839 = D.24838 & 64;
  if (D.24839 != 0) goto <D.20994>; else goto <D.24840>;
  <D.24840>:
  <D.24836>:
  method = method + 8;
  <D.20996>:
  D.24819 = klass->methods;
  D.24841 = klass->method.count;
  D.24842 = (long unsigned int) D.24841;
  D.24843 = D.24842 * 8;
  D.24844 = D.24819 + D.24843;
  if (D.24844 > method) goto <D.20995>; else goto <D.20994>;
  <D.20994>:
  D.24819 = klass->methods;
  D.24841 = klass->method.count;
  D.24842 = (long unsigned int) D.24841;
  D.24843 = D.24842 * 8;
  D.24844 = D.24819 + D.24843;
  if (D.24844 > method) goto <D.24845>; else goto <D.24846>;
  <D.24845>:
  *iter = method;
  D.24816 = *method;
  return D.24816;
  <D.24846>:
  D.24816 = 0B;
  return D.24816;
  <D.24818>:
  {
    struct MonoMethod * res;
    int i;
    int start_index;

    res = 0B;
    D.24828 = *iter;
    if (D.24828 == 0B) goto <D.24847>; else goto <D.24848>;
    <D.24847>:
    start_index = 0;
    goto <D.24849>;
    <D.24848>:
    D.24828 = *iter;
    D.24850 = (long int) D.24828;
    start_index = (int) D.24850;
    <D.24849>:
    i = start_index;
    goto <D.21003>;
    <D.21002>:
    {
      guint32 flags;

      D.24823 = klass->image;
      D.24851 = klass->method.first;
      i.143 = (unsigned int) i;
      D.24853 = D.24851 + i.143;
      D.24854 = (int) D.24853;
      flags = mono_metadata_decode_table_row_col (D.24823, 6, D.24854, 2);
      D.24855 = flags & 64;
      if (D.24855 != 0) goto <D.21001>; else goto <D.24856>;
      <D.24856>:
    }
    i = i + 1;
    <D.21003>:
    D.24841 = klass->method.count;
    i.143 = (unsigned int) i;
    if (D.24841 > i.143) goto <D.21002>; else goto <D.21001>;
    <D.21001>:
    D.24841 = klass->method.count;
    i.143 = (unsigned int) i;
    if (D.24841 > i.143) goto <D.24857>; else goto <D.24858>;
    <D.24857>:
    D.24823 = klass->image;
    D.24851 = klass->method.first;
    i.143 = (unsigned int) i;
    D.24853 = D.24851 + i.143;
    D.24859 = D.24853 + 1;
    D.24860 = D.24859 | 100663296;
    res = mono_get_method (D.24823, D.24860, klass);
    D.24861 = i + 1;
    D.24862 = (long unsigned int) D.24861;
    D.24863 = (void *) D.24862;
    *iter = D.24863;
    D.24816 = res;
    return D.24816;
    <D.24858>:
    D.24816 = 0B;
    return D.24816;
  }
}


print_implemented_interfaces (struct MonoClass * klass)
{
  short unsigned int D.24865;
  int D.24866;
  struct MonoClass * * D.24867;
  long unsigned int D.24868;
  long unsigned int D.24869;
  struct MonoClass * * D.24870;
  struct MonoClass * D.24871;
  short unsigned int D.24872;
  int D.24873;
  guint16 * D.24874;
  long unsigned int D.24875;
  guint16 * D.24876;
  short unsigned int D.24877;
  int D.24878;
  unsigned int D.24879;
  const char * D.24880;
  const char * D.24881;
  short unsigned int D.24884;
  int D.24885;
  guint8 * D.24887;
  int D.24888;
  sizetype D.24889;
  guint8 * D.24890;
  unsigned char D.24891;
  int D.24892;
  int D.24893;
  int D.24894;
  int D.24895;
  sizetype D.24897;
  guint8 * D.24898;
  unsigned char D.24899;
  int D.24900;
  int D.24901;
  int D.24902;
  int D.24903;
  _Bool D.24904;
  int D.24905;
  int D.24906;
  const char * D.24907;
  int D.24908;
  const char * D.24911;
  void * * D.24915;
  void * * D.24916;
  short unsigned int D.24917;
  int D.24918;
  const char * D.24919;
  int D.24920;
  unsigned int D.24921;
  const char * D.24922;
  unsigned int D.24923;
  unsigned int i.144;
  char * name;
  struct MonoError error;
  struct GPtrArray * ifaces;
  int i;
  int ancestor_level;

  try
    {
      ifaces = 0B;
      ancestor_level = 0;
      name = mono_type_get_full_name (klass);
      D.24865 = klass->interface_offsets_count;
      D.24866 = (int) D.24865;
      printf ("Packed interface table for class %s has size %d\n", name, D.24866);
      monoeg_g_free (name);
      i = 0;
      goto <D.19585>;
      <D.19584>:
      D.24867 = klass->interfaces_packed;
      D.24868 = (long unsigned int) i;
      D.24869 = D.24868 * 8;
      D.24870 = D.24867 + D.24869;
      D.24871 = *D.24870;
      D.24872 = D.24871->interface_id;
      D.24873 = (int) D.24872;
      D.24874 = klass->interface_offsets_packed;
      D.24868 = (long unsigned int) i;
      D.24875 = D.24868 * 2;
      D.24876 = D.24874 + D.24875;
      D.24877 = *D.24876;
      D.24878 = (int) D.24877;
      D.24867 = klass->interfaces_packed;
      D.24868 = (long unsigned int) i;
      D.24869 = D.24868 * 8;
      D.24870 = D.24867 + D.24869;
      D.24871 = *D.24870;
      D.24879 = D.24871->method.count;
      D.24867 = klass->interfaces_packed;
      D.24868 = (long unsigned int) i;
      D.24869 = D.24868 * 8;
      D.24870 = D.24867 + D.24869;
      D.24871 = *D.24870;
      D.24880 = D.24871->name_space;
      D.24867 = klass->interfaces_packed;
      D.24868 = (long unsigned int) i;
      D.24869 = D.24868 * 8;
      D.24870 = D.24867 + D.24869;
      D.24871 = *D.24870;
      D.24881 = D.24871->name;
      printf ("  [%03d][UUID %03d][SLOT %03d][SIZE  %03d] interface %s.%s\n", i, D.24873, D.24878, D.24879, D.24880, D.24881);
      i = i + 1;
      <D.19585>:
      D.24865 = klass->interface_offsets_count;
      D.24866 = (int) D.24865;
      if (D.24866 > i) goto <D.19584>; else goto <D.19586>;
      <D.19586>:
      printf ("Interface flags: ");
      i = 0;
      goto <D.19588>;
      <D.19587>:
      D.24884 = klass->max_interface_id;
      D.24885 = (int) D.24884;
      if (D.24885 >= i) goto <D.24886>; else goto <D.24882>;
      <D.24886>:
      D.24887 = klass->interface_bitmap;
      D.24888 = i >> 3;
      D.24889 = (sizetype) D.24888;
      D.24890 = D.24887 + D.24889;
      D.24891 = *D.24890;
      D.24892 = (int) D.24891;
      D.24893 = i & 7;
      D.24894 = D.24892 >> D.24893;
      D.24895 = D.24894 & 1;
      if (D.24895 != 0) goto <D.24896>; else goto <D.24882>;
      <D.24896>:
      printf ("(%d,T)", i);
      goto <D.24883>;
      <D.24882>:
      printf ("(%d,F)", i);
      <D.24883>:
      i = i + 1;
      <D.19588>:
      D.24884 = klass->max_interface_id;
      D.24885 = (int) D.24884;
      if (D.24885 >= i) goto <D.19587>; else goto <D.19589>;
      <D.19589>:
      printf ("\n");
      printf ("Dump interface flags:");
      i = 0;
      goto <D.19591>;
      <D.19590>:
      D.24887 = klass->interface_bitmap;
      D.24897 = (sizetype) i;
      D.24898 = D.24887 + D.24897;
      D.24899 = *D.24898;
      D.24900 = (int) D.24899;
      printf (" %02X", D.24900);
      i = i + 1;
      <D.19591>:
      D.24884 = klass->max_interface_id;
      D.24885 = (int) D.24884;
      D.24901 = D.24885 + 1;
      D.24902 = D.24901 >> 3;
      D.24884 = klass->max_interface_id;
      D.24885 = (int) D.24884;
      D.24901 = D.24885 + 1;
      D.24903 = D.24901 & 7;
      D.24904 = D.24903 != 0;
      D.24905 = (int) D.24904;
      D.24906 = D.24902 + D.24905;
      if (D.24906 > i) goto <D.19590>; else goto <D.19592>;
      <D.19592>:
      printf ("\n");
      goto <D.19598>;
      <D.19597>:
      D.24907 = klass->name;
      printf ("[LEVEL %d] Implemented interfaces by class %s:\n", ancestor_level, D.24907);
      ifaces = mono_class_get_implemented_interfaces (klass, &error);
      D.24908 = mono_error_ok (&error);
      if (D.24908 == 0) goto <D.24909>; else goto <D.24910>;
      <D.24909>:
      D.24911 = mono_error_get_message (&error);
      printf ("  Type failed due to %s\n", D.24911);
      mono_error_cleanup (&error);
      goto <D.24912>;
      <D.24910>:
      if (ifaces != 0B) goto <D.24913>; else goto <D.24914>;
      <D.24913>:
      i = 0;
      goto <D.19595>;
      <D.19594>:
      {
        struct MonoClass * ic;

        D.24915 = ifaces->pdata;
        D.24868 = (long unsigned int) i;
        D.24869 = D.24868 * 8;
        D.24916 = D.24915 + D.24869;
        ic = *D.24916;
        D.24917 = ic->interface_id;
        D.24918 = (int) D.24917;
        D.24919 = ic->name;
        printf ("  [UIID %d] interface %s\n", D.24918, D.24919);
        D.24917 = ic->interface_id;
        D.24918 = (int) D.24917;
        D.24920 = mono_class_interface_offset (klass, ic);
        D.24921 = ic->method.count;
        D.24922 = ic->name_space;
        D.24919 = ic->name;
        printf ("  [%03d][UUID %03d][SLOT %03d][SIZE  %03d] interface %s.%s\n", i, D.24918, D.24920, D.24921, D.24922, D.24919);
      }
      i = i + 1;
      <D.19595>:
      D.24923 = ifaces->len;
      i.144 = (unsigned int) i;
      if (D.24923 > i.144) goto <D.19594>; else goto <D.19596>;
      <D.19596>:
      monoeg_g_ptr_array_free (ifaces, 1);
      <D.24914>:
      <D.24912>:
      ancestor_level = ancestor_level + 1;
      klass = klass->parent;
      <D.19598>:
      if (klass != 0B) goto <D.19597>; else goto <D.19599>;
      <D.19599>:
    }
  finally
    {
      error = {CLOBBER};
    }
}


__attribute__((__artificial__, __gnu_inline__, __always_inline__))
printf (const char * restrict __fmt)
{
  int D.24925;

  D.24925 = __printf_chk (1, __fmt, __builtin_va_arg_pack ());
  return D.24925;
}


__attribute__((visibility ("hidden")))
mono_method_get_vtable_slot (struct MonoMethod * method)
{
  short int D.24927;
  struct MonoClass * D.24930;
  unsigned char D.24931;
  int D.24934;
  struct MonoGenericClass * D.24937;
  _Bool D.24938;
  long int D.24939;
  long int D.24940;
  struct MonoMethod * * D.24943;
  _Bool D.24944;
  long int D.24945;
  long int D.24946;
  long unsigned int D.24949;
  long unsigned int D.24950;
  struct MonoMethod * * D.24951;
  struct MonoMethod * D.24952;
  unsigned int D.24954;
  unsigned int i.145;
  _Bool D.24956;
  long int D.24957;
  long int D.24958;
  struct MonoMethod * * D.24961;
  _Bool D.24962;
  long int D.24963;
  long int D.24964;
  struct MonoMethod * * D.24967;
  struct MonoMethod * D.24968;
  short int D.24969;
  _Bool D.24970;
  long int D.24971;
  long int D.24972;

  D.24927 = method->slot;
  if (D.24927 == -1) goto <D.24928>; else goto <D.24929>;
  <D.24928>:
  D.24930 = method->klass;
  mono_class_setup_vtable (D.24930);
  D.24930 = method->klass;
  D.24931 = D.24930->exception_type;
  if (D.24931 != 0) goto <D.24932>; else goto <D.24933>;
  <D.24932>:
  D.24934 = -1;
  return D.24934;
  <D.24933>:
  D.24927 = method->slot;
  if (D.24927 == -1) goto <D.24935>; else goto <D.24936>;
  <D.24935>:
  {
    struct MonoClass * gklass;
    int i;

    D.24930 = method->klass;
    D.24937 = D.24930->generic_class;
    D.24938 = D.24937 == 0B;
    D.24939 = (long int) D.24938;
    D.24940 = __builtin_expect (D.24939, 0);
    if (D.24940 != 0) goto <D.24941>; else goto <D.24942>;
    <D.24941>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "class.c", 4676, "method->klass->generic_class");
    <D.24942>:
    D.24930 = method->klass;
    D.24937 = D.24930->generic_class;
    gklass = D.24937->container_class;
    D.24930 = method->klass;
    mono_class_setup_methods (D.24930);
    D.24930 = method->klass;
    D.24943 = D.24930->methods;
    D.24944 = D.24943 == 0B;
    D.24945 = (long int) D.24944;
    D.24946 = __builtin_expect (D.24945, 0);
    if (D.24946 != 0) goto <D.24947>; else goto <D.24948>;
    <D.24947>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "class.c", 4679, "method->klass->methods");
    <D.24948>:
    i = 0;
    goto <D.20049>;
    <D.20048>:
    D.24930 = method->klass;
    D.24943 = D.24930->methods;
    D.24949 = (long unsigned int) i;
    D.24950 = D.24949 * 8;
    D.24951 = D.24943 + D.24950;
    D.24952 = *D.24951;
    if (D.24952 == method) goto <D.20047>; else goto <D.24953>;
    <D.24953>:
    i = i + 1;
    <D.20049>:
    D.24930 = method->klass;
    D.24954 = D.24930->method.count;
    i.145 = (unsigned int) i;
    if (D.24954 > i.145) goto <D.20048>; else goto <D.20047>;
    <D.20047>:
    D.24930 = method->klass;
    D.24954 = D.24930->method.count;
    i.145 = (unsigned int) i;
    D.24956 = D.24954 <= i.145;
    D.24957 = (long int) D.24956;
    D.24958 = __builtin_expect (D.24957, 0);
    if (D.24958 != 0) goto <D.24959>; else goto <D.24960>;
    <D.24959>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "class.c", 4684, "i < method->klass->method.count");
    <D.24960>:
    D.24961 = gklass->methods;
    D.24962 = D.24961 == 0B;
    D.24963 = (long int) D.24962;
    D.24964 = __builtin_expect (D.24963, 0);
    if (D.24964 != 0) goto <D.24965>; else goto <D.24966>;
    <D.24965>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "class.c", 4685, "gklass->methods");
    <D.24966>:
    D.24961 = gklass->methods;
    D.24949 = (long unsigned int) i;
    D.24950 = D.24949 * 8;
    D.24967 = D.24961 + D.24950;
    D.24968 = *D.24967;
    D.24969 = D.24968->slot;
    method->slot = D.24969;
  }
  <D.24936>:
  D.24927 = method->slot;
  D.24970 = D.24927 == -1;
  D.24971 = (long int) D.24970;
  D.24972 = __builtin_expect (D.24971, 0);
  if (D.24972 != 0) goto <D.24973>; else goto <D.24974>;
  <D.24973>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "class.c", 4688, "method->slot != -1");
  <D.24974>:
  <D.24929>:
  D.24927 = method->slot;
  D.24934 = (int) D.24927;
  return D.24934;
}


__attribute__((visibility ("hidden")))
mono_method_get_vtable_index (struct MonoMethod * method)
{
  long unsigned int D.24976;
  long unsigned int D.24977;
  short unsigned int D.24980;
  int D.24981;
  int D.24982;
  struct MonoMethod * D.24985;
  long unsigned int D.24986;
  long unsigned int D.24987;
  int D.24990;

  D.24976 = BIT_FIELD_REF <*method, 64, 256>;
  D.24977 = D.24976 & 2251799813685248;
  if (D.24977 != 0) goto <D.24978>; else goto <D.24979>;
  <D.24978>:
  D.24980 = method->flags;
  D.24981 = (int) D.24980;
  D.24982 = D.24981 & 64;
  if (D.24982 != 0) goto <D.24983>; else goto <D.24984>;
  <D.24983>:
  {
    struct MonoMethodInflated * imethod;

    imethod = method;
    D.24985 = imethod->declaring;
    D.24986 = BIT_FIELD_REF <*D.24985, 64, 256>;
    D.24987 = D.24986 & 4503599627370496;
    if (D.24987 != 0) goto <D.24988>; else goto <D.24989>;
    <D.24988>:
    D.24985 = imethod->declaring;
    D.24990 = mono_method_get_vtable_slot (D.24985);
    return D.24990;
    <D.24989>:
  }
  <D.24984>:
  <D.24979>:
  D.24990 = mono_method_get_vtable_slot (method);
  return D.24990;
}


mono_class_init (struct MonoClass * class)
{
  _Bool D.24992;
  long int D.24993;
  long int D.24994;
  long unsigned int D.24997;
  long unsigned int D.24998;
  mono_bool D.25001;
  unsigned char D.25002;
  _Bool D.25003;
  long unsigned int D.25006;
  gchar * D.25009;
  int D.25010;
  int D.25013;
  struct MonoImage * D.25016;
  const char * D.25017;
  const char * D.25018;
  char * D.25019;
  unsigned char D.25022;
  long unsigned int D.25024;
  long unsigned int D.25025;
  unsigned char D.25028;
  int D.25031;
  struct MonoClass * D.25034;
  unsigned int D.25037;
  unsigned int D.25038;
  long unsigned int D.25041;
  long unsigned int D.25042;
  struct MonoGenericClass * D.25043;
  long unsigned int D.25046;
  long unsigned int D.25047;
  long unsigned int D.25050;
  long unsigned int D.25051;
  unsigned char D.25052;
  gchar * D.25057;
  unsigned int D.25060;
  unsigned int D.25061;
  unsigned int D.25064;
  short unsigned int D.25065;
  long unsigned int D.25068;
  long unsigned int D.25069;
  long unsigned int D.25075;
  long unsigned int D.25076;
  unsigned int D.25078;
  long unsigned int D.25081;
  long unsigned int D.25082;
  unsigned int D.25085;
  int D.25086;
  unsigned int D.25087;
  int D.25088;
  unsigned int D.25089;
  unsigned char D.25090;
  <unnamed-unsigned:4> D.25091;
  unsigned int D.25092;
  unsigned char D.25093;
  <unnamed-unsigned:1> D.25094;
  <unnamed-unsigned:1> D.25095;
  <unnamed-unsigned:1> D.25096;
  <unnamed-unsigned:1> D.25097;
  long unsigned int D.25099;
  struct MonoLoaderError * D.25103;
  unsigned char D.25105;
  guint32 iftmp.146;
  short unsigned int D.25112;
  unsigned int D.25115;
  int D.25116;
  int D.25117;
  unsigned int D.25118;
  unsigned int D.25119;
  struct MonoMethod * default_ghc.147;
  unsigned int D.25125;
  int D.25126;
  <unnamed-unsigned:1> D.25127;
  <unnamed-unsigned:1> D.25128;
  <unnamed-unsigned:1> D.25129;
  struct MonoClass * D.25135;
  struct MonoType * D.25136;
  int D.25137;
  _Bool D.25138;
  int D.25139;
  int D.25142;
  <unnamed-unsigned:1> D.25150;
  int D.25151;
  unsigned char D.25152;
  <unnamed-unsigned:1> D.25153;
  <unnamed-unsigned:1> D.25154;
  unsigned char D.25155;
  int D.25158;
  struct MonoImage * D.25164;
  short unsigned int D.25169;
  int D.25170;
  int D.25171;
  struct MonoMethod * * D.25176;
  long unsigned int D.25177;
  long unsigned int D.25178;
  struct MonoMethod * * D.25179;
  short unsigned int D.25180;
  int D.25181;
  int D.25182;
  const char * D.25185;
  int D.25186;
  unsigned int i.148;
  unsigned char D.25192;
  struct MonoLoaderError * D.25195;
  int D.25197;
  struct MonoLoaderError * D.25202;
  int D.25204;
  <unnamed type> D.25208;
  struct MonoLoaderError * D.25211;
  struct MonoLoaderError * D.25216;
  int D.25219;
  gchar * D.25222;
  void (*<T1fab>) (struct MonoClass *) mono_debugger_class_init_func.149;
  int i;
  struct MonoCachedClassInfo cached_info;
  gboolean has_cached_info;
  void leave = <<< error >>>;

  try
    {
      D.24992 = class == 0B;
      D.24993 = (long int) D.24992;
      D.24994 = __builtin_expect (D.24993, 0);
      if (D.24994 != 0) goto <D.24995>; else goto <D.24996>;
      <D.24995>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "class.c", 4915, "class");
      <D.24996>:
      D.24997 = BIT_FIELD_REF <*class, 64, 256>;
      D.24998 = D.24997 & 9223372036871487488;
      if (D.24998 != 0) goto <D.24999>; else goto <D.25000>;
      <D.24999>:
      D.25002 = class->exception_type;
      D.25003 = D.25002 == 0;
      D.25001 = (mono_bool) D.25003;
      return D.25001;
      <D.25000>:
      mono_loader_lock ();
      D.24997 = BIT_FIELD_REF <*class, 64, 256>;
      D.24998 = D.24997 & 9223372036871487488;
      if (D.24998 != 0) goto <D.25004>; else goto <D.25005>;
      <D.25004>:
      mono_loader_unlock ();
      D.25002 = class->exception_type;
      D.25003 = D.25002 == 0;
      D.25001 = (mono_bool) D.25003;
      return D.25001;
      <D.25005>:
      D.24997 = BIT_FIELD_REF <*class, 64, 256>;
      D.25006 = D.24997 & 4611686018427387904;
      if (D.25006 != 0) goto <D.25007>; else goto <D.25008>;
      <D.25007>:
      D.25009 = monoeg_strdup ("Recursive type definition detected");
      mono_class_set_failure (class, 7, D.25009);
      goto leave;
      <D.25008>:
      class->init_pending = 1;
      D.25010 = mono_verifier_is_enabled_for_class (class);
      if (D.25010 != 0) goto <D.25011>; else goto <D.25012>;
      <D.25011>:
      D.25013 = mono_verifier_verify_class (class);
      if (D.25013 == 0) goto <D.25014>; else goto <D.25015>;
      <D.25014>:
      D.25016 = class->image;
      D.25017 = class->name;
      D.25016 = class->image;
      D.25018 = D.25016->assembly_name;
      D.25019 = concat_two_strings_with_zero (D.25016, D.25017, D.25018);
      mono_class_set_failure (class, 7, D.25019);
      goto leave;
      <D.25015>:
      <D.25012>:
      D.25022 = class->byval_arg.type;
      if (D.25022 == 20) goto <D.25020>; else goto <D.25023>;
      <D.25023>:
      D.25022 = class->byval_arg.type;
      if (D.25022 == 29) goto <D.25020>; else goto <D.25021>;
      <D.25020>:
      {
        struct MonoClass * element_class;

        element_class = class->element_class;
        D.25024 = BIT_FIELD_REF <*element_class, 64, 256>;
        D.25025 = D.25024 & 9223372036854775808;
        if (D.25025 == 0) goto <D.25026>; else goto <D.25027>;
        <D.25026>:
        mono_class_init (element_class);
        <D.25027>:
        D.25028 = element_class->exception_type;
        if (D.25028 != 0) goto <D.25029>; else goto <D.25030>;
        <D.25029>:
        mono_class_set_failure (class, 7, 0B);
        goto leave;
        <D.25030>:
      }
      <D.25021>:
      D.25031 = mono_is_security_manager_active ();
      if (D.25031 != 0) goto <D.25032>; else goto <D.25033>;
      <D.25032>:
      D.25034 = class->parent;
      if (D.25034 != 0B) goto <D.25035>; else goto <D.25036>;
      <D.25035>:
      D.25034 = class->parent;
      D.25037 = D.25034->flags;
      D.25038 = D.25037 & 262144;
      if (D.25038 != 0) goto <D.25039>; else goto <D.25040>;
      <D.25039>:
      D.25034 = class->parent;
      mono_secman_inheritancedemand_class (class, D.25034);
      <D.25040>:
      <D.25036>:
      <D.25033>:
      D.25041 = mono_stats.initialized_class_count;
      D.25042 = D.25041 + 1;
      mono_stats.initialized_class_count = D.25042;
      D.25043 = class->generic_class;
      if (D.25043 != 0B) goto <D.25044>; else goto <D.25045>;
      <D.25044>:
      D.25043 = class->generic_class;
      D.25046 = BIT_FIELD_REF <*D.25043, 64, 192>;
      D.25047 = D.25046 & 9223372036854775808;
      if (D.25047 == 0) goto <D.25048>; else goto <D.25049>;
      <D.25048>:
      {
        struct MonoClass * gklass;

        D.25043 = class->generic_class;
        gklass = D.25043->container_class;
        D.25050 = mono_stats.generic_class_count;
        D.25051 = D.25050 + 1;
        mono_stats.generic_class_count = D.25051;
        class->method = gklass->method;
        class->field = gklass->field;
        mono_class_init (gklass);
        D.25052 = gklass->exception_type;
        if (D.25052 == 0) goto <D.25053>; else goto <D.25054>;
        <D.25053>:
        mono_class_setup_methods (gklass);
        <D.25054>:
        D.25052 = gklass->exception_type;
        if (D.25052 != 0) goto <D.25055>; else goto <D.25056>;
        <D.25055>:
        D.25057 = monoeg_g_strdup_printf ("Generic Type Defintion failed to init");
        mono_class_set_failure (class, 7, D.25057);
        goto leave;
        <D.25056>:
        D.25060 = class->flags;
        D.25061 = D.25060 & 32;
        if (D.25061 != 0) goto <D.25058>; else goto <D.25062>;
        <D.25062>:
        D.25022 = class->byval_arg.type;
        if (D.25022 == 19) goto <D.25058>; else goto <D.25063>;
        <D.25063>:
        D.25022 = class->byval_arg.type;
        if (D.25022 == 30) goto <D.25058>; else goto <D.25059>;
        <D.25058>:
        D.25064 = mono_get_unique_iid (class);
        D.25065 = (short unsigned int) D.25064;
        class->interface_id = D.25065;
        <D.25059>:
      }
      <D.25049>:
      <D.25045>:
      D.25034 = class->parent;
      if (D.25034 != 0B) goto <D.25066>; else goto <D.25067>;
      <D.25066>:
      D.25034 = class->parent;
      D.25068 = BIT_FIELD_REF <*D.25034, 64, 256>;
      D.25069 = D.25068 & 9223372036854775808;
      if (D.25069 == 0) goto <D.25070>; else goto <D.25071>;
      <D.25070>:
      D.25034 = class->parent;
      mono_class_init (D.25034);
      <D.25071>:
      <D.25067>:
      has_cached_info = mono_class_get_cached_class_info (class, &cached_info);
      D.25043 = class->generic_class;
      if (D.25043 != 0B) goto <D.25072>; else goto <D.25074>;
      <D.25074>:
      D.25016 = class->image;
      D.25075 = BIT_FIELD_REF <*D.25016, 64, 192>;
      D.25076 = D.25075 & 268435456;
      if (D.25076 != 0) goto <D.25072>; else goto <D.25077>;
      <D.25077>:
      D.25078 = class->type_token;
      if (D.25078 == 0) goto <D.25072>; else goto <D.25079>;
      <D.25079>:
      if (has_cached_info != 0) goto <D.25080>; else goto <D.25073>;
      <D.25080>:
      D.25081 = BIT_FIELD_REF <cached_info, 64, 0>;
      D.25082 = D.25081 & 268435456;
      if (D.25082 == 0) goto <D.25072>; else goto <D.25073>;
      <D.25072>:
      class->nested_classes_inited = 1;
      <D.25073>:
      if (has_cached_info != 0) goto <D.25083>; else goto <D.25084>;
      <D.25083>:
      D.25085 = cached_info.instance_size;
      D.25086 = (int) D.25085;
      class->instance_size = D.25086;
      D.25087 = cached_info.class_size;
      D.25088 = (int) D.25087;
      class->sizes.class_size = D.25088;
      D.25089 = cached_info.packing_size;
      D.25090 = (unsigned char) D.25089;
      D.25091 = (<unnamed-unsigned:4>) D.25090;
      class->packing_size = D.25091;
      D.25092 = cached_info.min_align;
      D.25093 = (unsigned char) D.25092;
      class->min_align = D.25093;
      D.25094 = cached_info.blittable;
      class->blittable = D.25094;
      D.25095 = cached_info.has_references;
      class->has_references = D.25095;
      D.25096 = cached_info.has_static_refs;
      class->has_static_refs = D.25096;
      D.25097 = cached_info.no_special_static_fields;
      class->no_special_static_fields = D.25097;
      goto <D.25098>;
      <D.25084>:
      D.24997 = BIT_FIELD_REF <*class, 64, 256>;
      D.25099 = D.24997 & 2305843009213693952;
      if (D.25099 == 0) goto <D.25100>; else goto <D.25101>;
      <D.25100>:
      mono_class_setup_fields (class);
      D.25002 = class->exception_type;
      if (D.25002 != 0) goto leave; else goto <D.25102>;
      <D.25102>:
      D.25103 = mono_loader_get_last_error ();
      if (D.25103 != 0B) goto leave; else goto <D.25104>;
      <D.25104>:
      <D.25101>:
      <D.25098>:
      D.25105 = class->rank;
      if (D.25105 != 0) goto <D.25106>; else goto <D.25107>;
      <D.25106>:
      D.25105 = class->rank;
      if (D.25105 > 1) goto <D.25109>; else goto <D.25110>;
      <D.25109>:
      iftmp.146 = 5;
      goto <D.25111>;
      <D.25110>:
      iftmp.146 = 4;
      <D.25111>:
      class->method.count = iftmp.146;
      D.25112 = class->interface_count;
      if (D.25112 != 0) goto <D.25113>; else goto <D.25114>;
      <D.25113>:
      {
        int count_generic;

        count_generic = generic_array_methods (class);
        D.25115 = class->method.count;
        D.25112 = class->interface_count;
        D.25116 = (int) D.25112;
        D.25117 = D.25116 * count_generic;
        D.25118 = (unsigned int) D.25117;
        D.25119 = D.25115 + D.25118;
        class->method.count = D.25119;
      }
      <D.25114>:
      <D.25107>:
      mono_class_setup_supertypes (class);
      default_ghc.147 = default_ghc;
      if (default_ghc.147 == 0B) goto <D.25121>; else goto <D.25122>;
      <D.25121>:
      initialize_object_slots (class);
      <D.25122>:
      if (has_cached_info != 0) goto <D.25123>; else goto <D.25124>;
      <D.25123>:
      D.25125 = cached_info.vtable_size;
      D.25126 = (int) D.25125;
      class->vtable_size = D.25126;
      D.25127 = cached_info.has_finalize;
      class->has_finalize = D.25127;
      class->has_finalize_inited = 1;
      D.25128 = cached_info.ghcimpl;
      class->ghcimpl = D.25128;
      D.25129 = cached_info.has_cctor;
      class->has_cctor = D.25129;
      goto <D.25130>;
      <D.25124>:
      D.25105 = class->rank;
      if (D.25105 == 1) goto <D.25133>; else goto <D.25131>;
      <D.25133>:
      D.25022 = class->byval_arg.type;
      if (D.25022 == 29) goto <D.25134>; else goto <D.25131>;
      <D.25134>:
      {
        static int szarray_vtable_size[2] = {0};
        int slot;

        D.25135 = class->element_class;
        D.25136 = &D.25135->byval_arg;
        D.25137 = mono_type_is_reference (D.25136);
        D.25138 = D.25137 == 0;
        slot = (int) D.25138;
        D.25139 = szarray_vtable_size[slot];
        if (D.25139 == 0) goto <D.25140>; else goto <D.25141>;
        <D.25140>:
        mono_class_setup_vtable (class);
        D.25142 = class->vtable_size;
        szarray_vtable_size[slot] = D.25142;
        goto <D.25143>;
        <D.25141>:
        D.25139 = szarray_vtable_size[slot];
        class->vtable_size = D.25139;
        <D.25143>:
        class->has_finalize_inited = 1;
      }
      goto <D.25132>;
      <D.25131>:
      D.25043 = class->generic_class;
      if (D.25043 != 0B) goto <D.25146>; else goto <D.25144>;
      <D.25146>:
      D.25060 = class->flags;
      D.25061 = D.25060 & 32;
      if (D.25061 == 0) goto <D.25147>; else goto <D.25144>;
      <D.25147>:
      D.25022 = class->byval_arg.type;
      if (D.25022 != 19) goto <D.25148>; else goto <D.25144>;
      <D.25148>:
      D.25022 = class->byval_arg.type;
      if (D.25022 != 30) goto <D.25149>; else goto <D.25144>;
      <D.25149>:
      {
        struct MonoClass * gklass;

        D.25043 = class->generic_class;
        gklass = D.25043->container_class;
        D.25150 = gklass->ghcimpl;
        class->ghcimpl = D.25150;
        D.25151 = mono_class_has_finalizer (gklass);
        D.25152 = (unsigned char) D.25151;
        D.25153 = (<unnamed-unsigned:1>) D.25152;
        class->has_finalize = D.25153;
        class->has_finalize_inited = 1;
        D.25154 = gklass->has_cctor;
        class->has_cctor = D.25154;
        mono_class_setup_vtable (gklass);
        D.25155 = gklass->exception_type;
        if (D.25155 != 0) goto <D.25156>; else goto <D.25157>;
        <D.25156>:
        mono_class_set_failure (class, 7, 0B);
        goto leave;
        <D.25157>:
        D.25158 = gklass->vtable_size;
        class->vtable_size = D.25158;
      }
      goto <D.25145>;
      <D.25144>:
      D.25060 = class->flags;
      D.25061 = D.25060 & 32;
      if (D.25061 == 0) goto <D.25162>; else goto <D.25159>;
      <D.25162>:
      D.25022 = class->byval_arg.type;
      if (D.25022 != 19) goto <D.25163>; else goto <D.25159>;
      <D.25163>:
      D.25022 = class->byval_arg.type;
      if (D.25022 != 30) goto <D.25160>; else goto <D.25159>;
      <D.25159>:
      D.25016 = class->image;
      D.25164 = mono_defaults.corlib;
      if (D.25016 != D.25164) goto <D.25160>; else goto <D.25161>;
      <D.25160>:
      {
        struct MonoMethod * cmethod;

        cmethod = 0B;
        D.25078 = class->type_token;
        if (D.25078 != 0) goto <D.25165>; else goto <D.25166>;
        <D.25165>:
        cmethod = find_method_in_metadata (class, ".cctor", 0, 2048);
        if (cmethod != 0B) goto <D.25167>; else goto <D.25168>;
        <D.25167>:
        D.25169 = cmethod->flags;
        D.25170 = (int) D.25169;
        D.25171 = D.25170 & 2048;
        if (D.25171 != 0) goto <D.25172>; else goto <D.25173>;
        <D.25172>:
        class->has_cctor = 1;
        <D.25173>:
        <D.25168>:
        goto <D.25174>;
        <D.25166>:
        mono_class_setup_methods (class);
        D.25002 = class->exception_type;
        if (D.25002 != 0) goto leave; else goto <D.25175>;
        <D.25175>:
        i = 0;
        goto <D.20146>;
        <D.20145>:
        {
          struct MonoMethod * method;

          D.25176 = class->methods;
          D.25177 = (long unsigned int) i;
          D.25178 = D.25177 * 8;
          D.25179 = D.25176 + D.25178;
          method = *D.25179;
          D.25180 = method->flags;
          D.25181 = (int) D.25180;
          D.25182 = D.25181 & 2048;
          if (D.25182 != 0) goto <D.25183>; else goto <D.25184>;
          <D.25183>:
          D.25185 = method->name;
          D.25186 = strcmp (".cctor", D.25185);
          if (D.25186 == 0) goto <D.25187>; else goto <D.25188>;
          <D.25187>:
          class->has_cctor = 1;
          goto <D.20144>;
          <D.25188>:
          <D.25184>:
        }
        i = i + 1;
        <D.20146>:
        D.25115 = class->method.count;
        i.148 = (unsigned int) i;
        if (D.25115 > i.148) goto <D.20145>; else goto <D.20144>;
        <D.20144>:
        <D.25174>:
      }
      <D.25161>:
      <D.25145>:
      <D.25132>:
      <D.25130>:
      D.25034 = class->parent;
      if (D.25034 != 0B) goto <D.25190>; else goto <D.25191>;
      <D.25190>:
      {
        int first_iface_slot;

        D.25034 = class->parent;
        mono_class_init (D.25034);
        D.25034 = class->parent;
        D.25192 = D.25034->exception_type;
        if (D.25192 != 0) goto <D.25193>; else goto <D.25194>;
        <D.25193>:
        mono_class_set_failure (class, 7, 0B);
        goto leave;
        <D.25194>:
        D.25195 = mono_loader_get_last_error ();
        if (D.25195 != 0B) goto leave; else goto <D.25196>;
        <D.25196>:
        D.25034 = class->parent;
        D.25197 = D.25034->vtable_size;
        if (D.25197 == 0) goto <D.25198>; else goto <D.25199>;
        <D.25198>:
        D.25034 = class->parent;
        mono_class_setup_vtable (D.25034);
        D.25034 = class->parent;
        D.25192 = D.25034->exception_type;
        if (D.25192 != 0) goto <D.25200>; else goto <D.25201>;
        <D.25200>:
        mono_class_set_failure (class, 7, 0B);
        goto leave;
        <D.25201>:
        D.25202 = mono_loader_get_last_error ();
        if (D.25202 != 0B) goto leave; else goto <D.25203>;
        <D.25203>:
        <D.25199>:
        D.25034 = class->parent;
        first_iface_slot = D.25034->vtable_size;
        D.25204 = mono_class_need_stelemref_method (class);
        if (D.25204 != 0) goto <D.25205>; else goto <D.25206>;
        <D.25205>:
        first_iface_slot = first_iface_slot + 1;
        <D.25206>:
        setup_interface_offsets (class, first_iface_slot, 1);
      }
      goto <D.25207>;
      <D.25191>:
      setup_interface_offsets (class, 0, 1);
      <D.25207>:
      D.25208 = mono_security_get_mode ();
      if (D.25208 == 1) goto <D.25209>; else goto <D.25210>;
      <D.25209>:
      mono_security_core_clr_check_inheritance (class);
      <D.25210>:
      D.25211 = mono_loader_get_last_error ();
      if (D.25211 != 0B) goto <D.25212>; else goto <D.25213>;
      <D.25212>:
      D.25002 = class->exception_type;
      if (D.25002 == 0) goto <D.25214>; else goto <D.25215>;
      <D.25214>:
      D.25216 = mono_loader_get_last_error ();
      set_failure_from_loader_error (class, D.25216);
      <D.25215>:
      mono_loader_clear_error ();
      <D.25213>:
      D.25043 = class->generic_class;
      if (D.25043 != 0B) goto <D.25217>; else goto <D.25218>;
      <D.25217>:
      D.25219 = mono_verifier_class_is_valid_generic_instantiation (class);
      if (D.25219 == 0) goto <D.25220>; else goto <D.25221>;
      <D.25220>:
      D.25222 = monoeg_strdup ("Invalid generic instantiation");
      mono_class_set_failure (class, 7, D.25222);
      <D.25221>:
      <D.25218>:
      goto leave;
      leave:
      mono_memory_barrier ();
      class->inited = 1;
      class->init_pending = 0;
      mono_loader_unlock ();
      mono_debugger_class_init_func.149 = mono_debugger_class_init_func;
      if (mono_debugger_class_init_func.149 != 0B) goto <D.25224>; else goto <D.25225>;
      <D.25224>:
      mono_debugger_class_init_func.149 = mono_debugger_class_init_func;
      mono_debugger_class_init_func.149 (class);
      <D.25225>:
      D.25002 = class->exception_type;
      D.25003 = D.25002 == 0;
      D.25001 = (mono_bool) D.25003;
      return D.25001;
    }
  finally
    {
      cached_info = {CLOBBER};
    }
}


mono_get_unique_iid (struct MonoClass * class)
{
  int iftmp.150;
  unsigned int D.25231;
  unsigned int D.25232;
  unsigned char D.25234;
  _Bool D.25237;
  long int D.25238;
  long int D.25239;
  struct MonoBitSet * global_interface_bitset.151;
  struct MonoBitSet * D.25245;
  unsigned int D.25248;
  int D.25249;
  unsigned int D.25250;
  unsigned int iid.152;
  struct MonoGenericClass * D.25252;
  struct MonoImage * D.25255;
  struct MonoBitSet * D.25256;
  unsigned int D.25259;
  int D.25262;
  unsigned int D.25263;
  struct MonoBitSet * D.25265;
  int mono_print_vtable.153;
  struct MonoType * D.25269;
  struct MonoGenericInst * D.25273;
  long unsigned int D.25274;
  long unsigned int D.25275;
  unsigned int D.25277;
  _Bool D.25278;
  long int D.25279;
  long int D.25280;
  char * D.25283;
  _Bool D.25284;
  long int D.25285;
  long int D.25286;
  guint D.25289;
  int iid;

  D.25231 = class->flags;
  D.25232 = D.25231 & 32;
  if (D.25232 == 0) goto <D.25233>; else goto <D.25229>;
  <D.25233>:
  D.25234 = class->byval_arg.type;
  if (D.25234 != 19) goto <D.25235>; else goto <D.25229>;
  <D.25235>:
  D.25234 = class->byval_arg.type;
  if (D.25234 != 30) goto <D.25236>; else goto <D.25229>;
  <D.25236>:
  iftmp.150 = 1;
  goto <D.25230>;
  <D.25229>:
  iftmp.150 = 0;
  <D.25230>:
  D.25237 = iftmp.150 != 0;
  D.25238 = (long int) D.25237;
  D.25239 = __builtin_expect (D.25238, 0);
  if (D.25239 != 0) goto <D.25240>; else goto <D.25241>;
  <D.25240>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "class.c", 2592, "MONO_CLASS_IS_INTERFACE (class)");
  <D.25241>:
  global_interface_bitset.151 = global_interface_bitset;
  if (global_interface_bitset.151 == 0B) goto <D.25243>; else goto <D.25244>;
  <D.25243>:
  D.25245 = mono_bitset_new (128, 0);
  global_interface_bitset = D.25245;
  <D.25244>:
  global_interface_bitset.151 = global_interface_bitset;
  iid = mono_bitset_find_first_unset (global_interface_bitset.151, -1);
  if (iid < 0) goto <D.25246>; else goto <D.25247>;
  <D.25246>:
  {
    int old_size;
    struct MonoBitSet * new_set;

    global_interface_bitset.151 = global_interface_bitset;
    D.25248 = mono_bitset_size (global_interface_bitset.151);
    old_size = (int) D.25248;
    global_interface_bitset.151 = global_interface_bitset;
    D.25249 = old_size * 2;
    D.25250 = (unsigned int) D.25249;
    new_set = mono_bitset_clone (global_interface_bitset.151, D.25250);
    global_interface_bitset.151 = global_interface_bitset;
    mono_bitset_free (global_interface_bitset.151);
    global_interface_bitset = new_set;
    iid = old_size;
  }
  <D.25247>:
  global_interface_bitset.151 = global_interface_bitset;
  iid.152 = (unsigned int) iid;
  mono_bitset_set (global_interface_bitset.151, iid.152);
  D.25252 = class->generic_class;
  if (D.25252 == 0B) goto <D.25253>; else goto <D.25254>;
  <D.25253>:
  D.25255 = class->image;
  D.25256 = D.25255->interface_bitset;
  if (D.25256 != 0B) goto <D.25257>; else goto <D.25258>;
  <D.25257>:
  D.25255 = class->image;
  D.25256 = D.25255->interface_bitset;
  D.25259 = mono_bitset_size (D.25256);
  iid.152 = (unsigned int) iid;
  if (D.25259 <= iid.152) goto <D.25260>; else goto <D.25261>;
  <D.25260>:
  {
    struct MonoBitSet * new_set;

    D.25255 = class->image;
    D.25256 = D.25255->interface_bitset;
    D.25262 = iid + 1;
    D.25263 = (unsigned int) D.25262;
    new_set = mono_bitset_clone (D.25256, D.25263);
    D.25255 = class->image;
    D.25256 = D.25255->interface_bitset;
    mono_bitset_free (D.25256);
    D.25255 = class->image;
    D.25255->interface_bitset = new_set;
  }
  <D.25261>:
  goto <D.25264>;
  <D.25258>:
  D.25255 = class->image;
  D.25262 = iid + 1;
  D.25263 = (unsigned int) D.25262;
  D.25265 = mono_bitset_new (D.25263, 0);
  D.25255->interface_bitset = D.25265;
  <D.25264>:
  D.25255 = class->image;
  D.25256 = D.25255->interface_bitset;
  iid.152 = (unsigned int) iid;
  mono_bitset_set (D.25256, iid.152);
  <D.25254>:
  mono_print_vtable.153 = mono_print_vtable;
  if (mono_print_vtable.153 != 0) goto <D.25267>; else goto <D.25268>;
  <D.25267>:
  {
    int generic_id;
    char * type_name;

    D.25269 = &class->byval_arg;
    type_name = mono_type_full_name (D.25269);
    D.25252 = class->generic_class;
    if (D.25252 != 0B) goto <D.25272>; else goto <D.25270>;
    <D.25272>:
    D.25252 = class->generic_class;
    D.25273 = D.25252->context.class_inst;
    D.25274 = BIT_FIELD_REF <*D.25273, 64, 0>;
    D.25275 = D.25274 & 512;
    if (D.25275 == 0) goto <D.25276>; else goto <D.25270>;
    <D.25276>:
    D.25252 = class->generic_class;
    D.25273 = D.25252->context.class_inst;
    D.25277 = D.25273->id;
    generic_id = (int) D.25277;
    D.25278 = generic_id == 0;
    D.25279 = (long int) D.25278;
    D.25280 = __builtin_expect (D.25279, 0);
    if (D.25280 != 0) goto <D.25281>; else goto <D.25282>;
    <D.25281>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "class.c", 2627, "generic_id != 0");
    <D.25282>:
    goto <D.25271>;
    <D.25270>:
    generic_id = 0;
    <D.25271>:
    D.25255 = class->image;
    D.25283 = D.25255->name;
    printf ("Interface: assigned id %d to %s|%s|%d\n", iid, D.25283, type_name, generic_id);
    monoeg_g_free (type_name);
  }
  <D.25268>:
  D.25284 = iid > 65535;
  D.25285 = (long int) D.25284;
  D.25286 = __builtin_expect (D.25285, 0);
  if (D.25286 != 0) goto <D.25287>; else goto <D.25288>;
  <D.25287>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "class.c", 2636, "iid <= 65535");
  <D.25288>:
  D.25289 = (guint) iid;
  return D.25289;
}


mono_class_get_cached_class_info (struct MonoClass * klass, struct MonoCachedClassInfo * res)
{
  gboolean (*<T1fe2>) (struct MonoClass *, struct MonoCachedClassInfo *) get_cached_class_info.154;
  gboolean D.25294;

  get_cached_class_info.154 = get_cached_class_info;
  if (get_cached_class_info.154 == 0B) goto <D.25292>; else goto <D.25293>;
  <D.25292>:
  D.25294 = 0;
  return D.25294;
  <D.25293>:
  get_cached_class_info.154 = get_cached_class_info;
  D.25294 = get_cached_class_info.154 (klass, res);
  return D.25294;
}


initialize_object_slots (struct MonoClass * class)
{
  struct MonoMethod * default_ghc.155;
  struct MonoClass * D.25299;
  struct MonoMethod * * D.25302;
  long unsigned int D.25303;
  long unsigned int D.25304;
  struct MonoMethod * * D.25305;
  const char * D.25306;
  int D.25307;
  int D.25311;
  int D.25314;
  int ghc_slot.156;
  _Bool D.25316;
  long int D.25317;
  long int D.25318;
  long unsigned int D.25321;
  long unsigned int D.25322;
  struct MonoMethod * * D.25323;
  struct MonoMethod * D.25324;
  int finalize_slot.157;
  _Bool D.25326;
  long int D.25327;
  long int D.25328;
  long unsigned int D.25331;
  long unsigned int D.25332;
  struct MonoMethod * * D.25333;
  struct MonoMethod * D.25334;
  int i;

  default_ghc.155 = default_ghc;
  if (default_ghc.155 != 0B) goto <D.25297>; else goto <D.25298>;
  <D.25297>:
  return;
  <D.25298>:
  D.25299 = mono_defaults.object_class;
  if (D.25299 == class) goto <D.25300>; else goto <D.25301>;
  <D.25300>:
  mono_class_setup_vtable (class);
  i = 0;
  goto <D.20064>;
  <D.20063>:
  {
    struct MonoMethod * cm;

    D.25302 = class->vtable;
    D.25303 = (long unsigned int) i;
    D.25304 = D.25303 * 8;
    D.25305 = D.25302 + D.25304;
    cm = *D.25305;
    D.25306 = cm->name;
    D.25307 = strcmp (D.25306, "GetHashCode");
    if (D.25307 == 0) goto <D.25308>; else goto <D.25309>;
    <D.25308>:
    ghc_slot = i;
    goto <D.25310>;
    <D.25309>:
    D.25306 = cm->name;
    D.25311 = strcmp (D.25306, "Finalize");
    if (D.25311 == 0) goto <D.25312>; else goto <D.25313>;
    <D.25312>:
    finalize_slot = i;
    <D.25313>:
    <D.25310>:
  }
  i = i + 1;
  <D.20064>:
  D.25314 = class->vtable_size;
  if (D.25314 > i) goto <D.20063>; else goto <D.20065>;
  <D.20065>:
  ghc_slot.156 = ghc_slot;
  D.25316 = ghc_slot.156 <= 0;
  D.25317 = (long int) D.25316;
  D.25318 = __builtin_expect (D.25317, 0);
  if (D.25318 != 0) goto <D.25319>; else goto <D.25320>;
  <D.25319>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "class.c", 4736, "ghc_slot > 0");
  <D.25320>:
  D.25302 = class->vtable;
  ghc_slot.156 = ghc_slot;
  D.25321 = (long unsigned int) ghc_slot.156;
  D.25322 = D.25321 * 8;
  D.25323 = D.25302 + D.25322;
  D.25324 = *D.25323;
  default_ghc = D.25324;
  finalize_slot.157 = finalize_slot;
  D.25326 = finalize_slot.157 <= 0;
  D.25327 = (long int) D.25326;
  D.25328 = __builtin_expect (D.25327, 0);
  if (D.25328 != 0) goto <D.25329>; else goto <D.25330>;
  <D.25329>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "class.c", 4739, "finalize_slot > 0");
  <D.25330>:
  D.25302 = class->vtable;
  finalize_slot.157 = finalize_slot;
  D.25331 = (long unsigned int) finalize_slot.157;
  D.25332 = D.25331 * 8;
  D.25333 = D.25302 + D.25332;
  D.25334 = *D.25333;
  default_finalize = D.25334;
  <D.25301>:
}


find_method_in_metadata (struct MonoClass * klass, const char * name, int param_count, int flags)
{
  struct MonoImage * D.25336;
  unsigned int D.25337;
  unsigned int i.158;
  unsigned int D.25339;
  int D.25340;
  unsigned int D.25341;
  const char * D.25342;
  int D.25343;
  unsigned int D.25346;
  unsigned int D.25347;
  short unsigned int D.25352;
  int D.25353;
  unsigned int D.25356;
  struct MonoMethod * D.25357;
  struct MonoMethod * res;
  int i;

  res = 0B;
  i = 0;
  goto <D.21121>;
  <D.21120>:
  {
    guint32 cols[6];
    struct MonoMethod * method;
    struct MonoMethodSignature * sig;

    try
      {
        D.25336 = klass->image;
        D.25337 = klass->method.first;
        i.158 = (unsigned int) i;
        D.25339 = D.25337 + i.158;
        D.25340 = (int) D.25339;
        mono_metadata_decode_table_row (D.25336, 6, D.25340, &cols, 6);
        D.25336 = klass->image;
        D.25341 = cols[3];
        D.25342 = mono_metadata_string_heap (D.25336, D.25341);
        D.25343 = strcmp (D.25342, name);
        if (D.25343 == 0) goto <D.25344>; else goto <D.25345>;
        <D.25344>:
        D.25336 = klass->image;
        D.25337 = klass->method.first;
        i.158 = (unsigned int) i;
        D.25339 = D.25337 + i.158;
        D.25346 = D.25339 + 1;
        D.25347 = D.25346 | 100663296;
        method = mono_get_method (D.25336, D.25347, klass);
        if (param_count == -1) goto <D.25348>; else goto <D.25349>;
        <D.25348>:
        res = method;
        goto <D.21119>;
        <D.25349>:
        sig = mono_method_signature (method);
        if (sig != 0B) goto <D.25350>; else goto <D.25351>;
        <D.25350>:
        D.25352 = sig->param_count;
        D.25353 = (int) D.25352;
        if (D.25353 == param_count) goto <D.25354>; else goto <D.25355>;
        <D.25354>:
        res = method;
        goto <D.21119>;
        <D.25355>:
        <D.25351>:
        <D.25345>:
      }
    finally
      {
        cols = {CLOBBER};
      }
  }
  i = i + 1;
  <D.21121>:
  D.25356 = klass->method.count;
  i.158 = (unsigned int) i;
  if (D.25356 > i.158) goto <D.21120>; else goto <D.21119>;
  <D.21119>:
  D.25357 = res;
  return D.25357;
}


__attribute__((visibility ("hidden")))
mono_class_has_finalizer (struct MonoClass * klass)
{
  long unsigned int D.25361;
  long unsigned int D.25362;
  unsigned int D.25365;
  unsigned int D.25366;
  unsigned char D.25369;
  long unsigned int D.25374;
  long unsigned int D.25375;
  struct MonoClass * D.25380;
  long unsigned int D.25382;
  long unsigned int D.25383;
  unsigned char D.25387;
  struct MonoLoaderError * D.25389;
  struct MonoMethod * * D.25391;
  int finalize_slot.159;
  long unsigned int D.25393;
  long unsigned int D.25394;
  struct MonoMethod * * D.25395;
  int D.25398;
  _Bool D.25399;
  long int D.25400;
  long int D.25401;
  long unsigned int D.25406;
  long unsigned int D.25407;
  struct MonoMethod * default_finalize.160;
  gboolean D.25413;
  <unnamed-unsigned:1> D.25414;
  void leave = <<< error >>>;

  D.25361 = BIT_FIELD_REF <*klass, 64, 256>;
  D.25362 = D.25361 & 134217728;
  if (D.25362 == 0) goto <D.25363>; else goto <D.25364>;
  <D.25363>:
  {
    struct MonoClass * class;

    class = klass;
    mono_loader_lock ();
    D.25365 = class->flags;
    D.25366 = D.25365 & 32;
    if (D.25366 == 0) goto <D.25367>; else goto <D.25368>;
    <D.25367>:
    D.25369 = class->byval_arg.type;
    if (D.25369 != 19) goto <D.25370>; else goto <D.25371>;
    <D.25370>:
    D.25369 = class->byval_arg.type;
    if (D.25369 != 30) goto <D.25372>; else goto <D.25373>;
    <D.25372>:
    D.25374 = BIT_FIELD_REF <*class, 64, 256>;
    D.25375 = D.25374 & 1152921504606846976;
    if (D.25375 == 0) goto <D.25376>; else goto <D.25377>;
    <D.25376>:
    {
      struct MonoMethod * cmethod;

      cmethod = 0B;
      D.25380 = class->parent;
      if (D.25380 != 0B) goto <D.25381>; else goto <D.25378>;
      <D.25381>:
      D.25380 = class->parent;
      D.25382 = BIT_FIELD_REF <*D.25380, 64, 256>;
      D.25383 = D.25382 & 4398046511104;
      if (D.25383 != 0) goto <D.25384>; else goto <D.25378>;
      <D.25384>:
      class->has_finalize = 1;
      goto <D.25379>;
      <D.25378>:
      D.25380 = class->parent;
      if (D.25380 != 0B) goto <D.25385>; else goto <D.25386>;
      <D.25385>:
      mono_class_setup_vtable (class);
      D.25387 = class->exception_type;
      if (D.25387 != 0) goto leave; else goto <D.25388>;
      <D.25388>:
      D.25389 = mono_loader_get_last_error ();
      if (D.25389 != 0B) goto leave; else goto <D.25390>;
      <D.25390>:
      D.25391 = class->vtable;
      finalize_slot.159 = finalize_slot;
      D.25393 = (long unsigned int) finalize_slot.159;
      D.25394 = D.25393 * 8;
      D.25395 = D.25391 + D.25394;
      cmethod = *D.25395;
      <D.25386>:
      if (cmethod != 0B) goto <D.25396>; else goto <D.25397>;
      <D.25396>:
      D.25398 = class->vtable_size;
      finalize_slot.159 = finalize_slot;
      D.25399 = D.25398 <= finalize_slot.159;
      D.25400 = (long int) D.25399;
      D.25401 = __builtin_expect (D.25400, 0);
      if (D.25401 != 0) goto <D.25402>; else goto <D.25403>;
      <D.25402>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "class.c", 5201, "class->vtable_size > finalize_slot");
      <D.25403>:
      class->has_finalize = 0;
      D.25380 = class->parent;
      if (D.25380 != 0B) goto <D.25404>; else goto <D.25405>;
      <D.25404>:
      D.25406 = BIT_FIELD_REF <*cmethod, 64, 256>;
      D.25407 = D.25406 & 2251799813685248;
      if (D.25407 != 0) goto <D.25408>; else goto <D.25409>;
      <D.25408>:
      cmethod = MEM[(struct MonoMethodInflated *)cmethod].declaring;
      <D.25409>:
      default_finalize.160 = default_finalize;
      if (cmethod != default_finalize.160) goto <D.25411>; else goto <D.25412>;
      <D.25411>:
      class->has_finalize = 1;
      <D.25412>:
      <D.25405>:
      <D.25397>:
      <D.25379>:
    }
    <D.25377>:
    <D.25373>:
    <D.25371>:
    <D.25368>:
    mono_memory_barrier ();
    klass->has_finalize_inited = 1;
    mono_loader_unlock ();
  }
  <D.25364>:
  D.25414 = klass->has_finalize;
  D.25413 = (gboolean) D.25414;
  return D.25413;
  leave:
  mono_loader_unlock ();
  D.25413 = 0;
  return D.25413;
}


__attribute__((visibility ("hidden")))
mono_is_corlib_image (struct MonoImage * image)
{
  long unsigned int D.25416;
  long unsigned int D.25417;
  gboolean D.25420;
  int iftmp.161;
  struct MonoAssembly * D.25424;
  const char * D.25426;
  int D.25427;
  struct MonoImage * D.25429;
  _Bool D.25430;

  D.25416 = BIT_FIELD_REF <*image, 64, 192>;
  D.25417 = D.25416 & 268435456;
  if (D.25417 != 0) goto <D.25418>; else goto <D.25419>;
  <D.25418>:
  D.25424 = image->assembly;
  if (D.25424 != 0B) goto <D.25425>; else goto <D.25422>;
  <D.25425>:
  D.25424 = image->assembly;
  D.25426 = D.25424->aname.name;
  D.25427 = strcmp (D.25426, "mscorlib");
  if (D.25427 == 0) goto <D.25428>; else goto <D.25422>;
  <D.25428>:
  iftmp.161 = 1;
  goto <D.25423>;
  <D.25422>:
  iftmp.161 = 0;
  <D.25423>:
  D.25420 = iftmp.161;
  return D.25420;
  <D.25419>:
  D.25429 = mono_defaults.corlib;
  D.25430 = D.25429 == image;
  D.25420 = (gboolean) D.25430;
  return D.25420;
}


__attribute__((visibility ("hidden")))
mono_class_setup_mono_type (struct MonoClass * class)
{
  struct MonoImage * D.25432;
  int D.25435;
  int D.25438;
  int D.25442;
  int D.25446;
  unsigned char D.25449;
  int D.25451;
  int D.25455;
  long unsigned int D.25458;
  long unsigned int D.25459;
  int D.25464;
  char D.25467;
  int D.25468;
  int D.25469;
  int D.25473;
  int D.25476;
  int D.25479;
  int D.25482;
  int D.25486;
  int D.25490;
  int D.25494;
  int D.25497;
  int D.25501;
  int D.25504;
  int D.25508;
  int D.25512;
  int D.25516;
  int D.25519;
  int D.25522;
  unsigned char D.25525;
  unsigned int D.25528;
  unsigned int D.25529;
  unsigned int D.25532;
  short unsigned int D.25533;
  const char * name;
  const char * nspace;
  gboolean is_corlib;

  name = class->name;
  nspace = class->name_space;
  D.25432 = class->image;
  is_corlib = mono_is_corlib_image (D.25432);
  class->this_arg.byref = 1;
  class->this_arg.data.klass = class;
  class->this_arg.type = 18;
  class->byval_arg.data.klass = class;
  class->byval_arg.type = 18;
  if (is_corlib != 0) goto <D.25433>; else goto <D.25434>;
  <D.25433>:
  D.25435 = strcmp (nspace, "System");
  if (D.25435 == 0) goto <D.25436>; else goto <D.25437>;
  <D.25436>:
  D.25438 = strcmp (name, "ValueType");
  if (D.25438 == 0) goto <D.25439>; else goto <D.25440>;
  <D.25439>:
  class->blittable = 1;
  goto <D.25441>;
  <D.25440>:
  D.25442 = strcmp (name, "Enum");
  if (D.25442 == 0) goto <D.25443>; else goto <D.25444>;
  <D.25443>:
  class->valuetype = 0;
  class->enumtype = 0;
  goto <D.25445>;
  <D.25444>:
  D.25446 = strcmp (name, "Object");
  if (D.25446 == 0) goto <D.25447>; else goto <D.25448>;
  <D.25447>:
  class->byval_arg.type = 28;
  D.25449 = class->byval_arg.type;
  class->this_arg.type = D.25449;
  goto <D.25450>;
  <D.25448>:
  D.25451 = strcmp (name, "String");
  if (D.25451 == 0) goto <D.25452>; else goto <D.25453>;
  <D.25452>:
  class->byval_arg.type = 14;
  D.25449 = class->byval_arg.type;
  class->this_arg.type = D.25449;
  goto <D.25454>;
  <D.25453>:
  D.25455 = strcmp (name, "TypedReference");
  if (D.25455 == 0) goto <D.25456>; else goto <D.25457>;
  <D.25456>:
  class->byval_arg.type = 22;
  D.25449 = class->byval_arg.type;
  class->this_arg.type = D.25449;
  <D.25457>:
  <D.25454>:
  <D.25450>:
  <D.25445>:
  <D.25441>:
  <D.25437>:
  <D.25434>:
  D.25458 = BIT_FIELD_REF <*class, 64, 256>;
  D.25459 = D.25458 & 1152921504606846976;
  if (D.25459 != 0) goto <D.25460>; else goto <D.25461>;
  <D.25460>:
  {
    int t;

    t = 17;
    if (is_corlib != 0) goto <D.25462>; else goto <D.25463>;
    <D.25462>:
    D.25464 = strcmp (nspace, "System");
    if (D.25464 == 0) goto <D.25465>; else goto <D.25466>;
    <D.25465>:
    D.25467 = *name;
    D.25468 = (int) D.25467;
    switch (D.25468) <default: <D.20173>, case 66: <D.20164>, case 67: <D.20166>, case 68: <D.20167>, case 73: <D.20168>, case 83: <D.20169>, case 84: <D.20171>, case 85: <D.20170>, case 86: <D.20172>>
    <D.20164>:
    D.25469 = strcmp (name, "Boolean");
    if (D.25469 == 0) goto <D.25470>; else goto <D.25471>;
    <D.25470>:
    t = 2;
    goto <D.25472>;
    <D.25471>:
    D.25473 = strcmp (name, "Byte");
    if (D.25473 == 0) goto <D.25474>; else goto <D.25475>;
    <D.25474>:
    t = 5;
    class->blittable = 1;
    <D.25475>:
    <D.25472>:
    goto <D.20165>;
    <D.20166>:
    D.25476 = strcmp (name, "Char");
    if (D.25476 == 0) goto <D.25477>; else goto <D.25478>;
    <D.25477>:
    t = 3;
    <D.25478>:
    goto <D.20165>;
    <D.20167>:
    D.25479 = strcmp (name, "Double");
    if (D.25479 == 0) goto <D.25480>; else goto <D.25481>;
    <D.25480>:
    t = 13;
    class->blittable = 1;
    <D.25481>:
    goto <D.20165>;
    <D.20168>:
    D.25482 = strcmp (name, "Int32");
    if (D.25482 == 0) goto <D.25483>; else goto <D.25484>;
    <D.25483>:
    t = 8;
    class->blittable = 1;
    goto <D.25485>;
    <D.25484>:
    D.25486 = strcmp (name, "Int16");
    if (D.25486 == 0) goto <D.25487>; else goto <D.25488>;
    <D.25487>:
    t = 6;
    class->blittable = 1;
    goto <D.25489>;
    <D.25488>:
    D.25490 = strcmp (name, "Int64");
    if (D.25490 == 0) goto <D.25491>; else goto <D.25492>;
    <D.25491>:
    t = 10;
    class->blittable = 1;
    goto <D.25493>;
    <D.25492>:
    D.25494 = strcmp (name, "IntPtr");
    if (D.25494 == 0) goto <D.25495>; else goto <D.25496>;
    <D.25495>:
    t = 24;
    class->blittable = 1;
    <D.25496>:
    <D.25493>:
    <D.25489>:
    <D.25485>:
    goto <D.20165>;
    <D.20169>:
    D.25497 = strcmp (name, "Single");
    if (D.25497 == 0) goto <D.25498>; else goto <D.25499>;
    <D.25498>:
    t = 12;
    class->blittable = 1;
    goto <D.25500>;
    <D.25499>:
    D.25501 = strcmp (name, "SByte");
    if (D.25501 == 0) goto <D.25502>; else goto <D.25503>;
    <D.25502>:
    t = 4;
    class->blittable = 1;
    <D.25503>:
    <D.25500>:
    goto <D.20165>;
    <D.20170>:
    D.25504 = strcmp (name, "UInt32");
    if (D.25504 == 0) goto <D.25505>; else goto <D.25506>;
    <D.25505>:
    t = 9;
    class->blittable = 1;
    goto <D.25507>;
    <D.25506>:
    D.25508 = strcmp (name, "UInt16");
    if (D.25508 == 0) goto <D.25509>; else goto <D.25510>;
    <D.25509>:
    t = 7;
    class->blittable = 1;
    goto <D.25511>;
    <D.25510>:
    D.25512 = strcmp (name, "UInt64");
    if (D.25512 == 0) goto <D.25513>; else goto <D.25514>;
    <D.25513>:
    t = 11;
    class->blittable = 1;
    goto <D.25515>;
    <D.25514>:
    D.25516 = strcmp (name, "UIntPtr");
    if (D.25516 == 0) goto <D.25517>; else goto <D.25518>;
    <D.25517>:
    t = 25;
    class->blittable = 1;
    <D.25518>:
    <D.25515>:
    <D.25511>:
    <D.25507>:
    goto <D.20165>;
    <D.20171>:
    D.25519 = strcmp (name, "TypedReference");
    if (D.25519 == 0) goto <D.25520>; else goto <D.25521>;
    <D.25520>:
    t = 22;
    class->blittable = 1;
    <D.25521>:
    goto <D.20165>;
    <D.20172>:
    D.25522 = strcmp (name, "Void");
    if (D.25522 == 0) goto <D.25523>; else goto <D.25524>;
    <D.25523>:
    t = 1;
    <D.25524>:
    goto <D.20165>;
    <D.20173>:
    goto <D.20165>;
    <D.20165>:
    <D.25466>:
    <D.25463>:
    D.25525 = (unsigned char) t;
    class->byval_arg.type = D.25525;
    D.25449 = class->byval_arg.type;
    class->this_arg.type = D.25449;
  }
  <D.25461>:
  D.25528 = class->flags;
  D.25529 = D.25528 & 32;
  if (D.25529 != 0) goto <D.25526>; else goto <D.25530>;
  <D.25530>:
  D.25449 = class->byval_arg.type;
  if (D.25449 == 19) goto <D.25526>; else goto <D.25531>;
  <D.25531>:
  D.25449 = class->byval_arg.type;
  if (D.25449 == 30) goto <D.25526>; else goto <D.25527>;
  <D.25526>:
  D.25532 = mono_get_unique_iid (class);
  D.25533 = (short unsigned int) D.25532;
  class->interface_id = D.25533;
  <D.25527>:
}


__attribute__((visibility ("hidden")))
mono_class_setup_parent (struct MonoClass * class, struct MonoClass * parent)
{
  struct MonoImage * D.25535;
  int iftmp.162;
  const char * D.25539;
  int D.25540;
  const char * D.25545;
  int D.25546;
  int D.25549;
  unsigned int D.25554;
  unsigned int D.25555;
  unsigned char D.25557;
  unsigned int D.25560;
  struct MonoClass * D.25563;
  struct MonoGenericClass * D.25568;
  const char * D.25571;
  <unnamed-unsigned:1> D.25574;
  <unnamed-unsigned:1> D.25575;
  <unnamed-unsigned:1> D.25576;
  long unsigned int D.25580;
  long unsigned int D.25581;
  char D.25584;
  int D.25587;
  int D.25592;
  int D.25597;
  struct MonoClass * D.25602;
  long unsigned int D.25603;
  long unsigned int D.25604;
  struct MonoImage * D.25606;
  int D.25607;
  const char * D.25609;
  int D.25610;
  const char * D.25612;
  int D.25613;
  int D.25614;
  int D.25617;
  int D.25620;
  <unnamed-unsigned:1> D.25623;
  gboolean system_namespace;
  gboolean is_corlib;

  D.25535 = class->image;
  is_corlib = mono_is_corlib_image (D.25535);
  D.25539 = class->name_space;
  D.25540 = strcmp (D.25539, "System");
  if (D.25540 == 0) goto <D.25541>; else goto <D.25537>;
  <D.25541>:
  if (is_corlib != 0) goto <D.25542>; else goto <D.25537>;
  <D.25542>:
  iftmp.162 = 1;
  goto <D.25538>;
  <D.25537>:
  iftmp.162 = 0;
  <D.25538>:
  system_namespace = iftmp.162;
  if (system_namespace != 0) goto <D.25543>; else goto <D.25544>;
  <D.25543>:
  D.25545 = class->name;
  D.25546 = strcmp (D.25545, "Object");
  if (D.25546 == 0) goto <D.25547>; else goto <D.25548>;
  <D.25547>:
  class->parent = 0B;
  class->instance_size = 16;
  return;
  <D.25548>:
  <D.25544>:
  D.25545 = class->name;
  D.25549 = strcmp (D.25545, "<Module>");
  if (D.25549 == 0) goto <D.25550>; else goto <D.25551>;
  <D.25550>:
  class->parent = 0B;
  class->instance_size = 0;
  return;
  <D.25551>:
  D.25554 = class->flags;
  D.25555 = D.25554 & 32;
  if (D.25555 == 0) goto <D.25556>; else goto <D.25552>;
  <D.25556>:
  D.25557 = class->byval_arg.type;
  if (D.25557 != 19) goto <D.25558>; else goto <D.25552>;
  <D.25558>:
  D.25557 = class->byval_arg.type;
  if (D.25557 != 30) goto <D.25559>; else goto <D.25552>;
  <D.25559>:
  D.25554 = class->flags;
  D.25560 = D.25554 & 4096;
  if (D.25560 != 0) goto <D.25561>; else goto <D.25562>;
  <D.25561>:
  init_com_from_comimport (class);
  D.25563 = mono_defaults.object_class;
  if (D.25563 == parent) goto <D.25564>; else goto <D.25565>;
  <D.25564>:
  parent = mono_class_get_com_object_class ();
  <D.25565>:
  <D.25562>:
  if (parent == 0B) goto <D.25566>; else goto <D.25567>;
  <D.25566>:
  parent = mono_defaults.object_class;
  mono_class_set_failure (class, 7, 0B);
  <D.25567>:
  class->parent = parent;
  D.25568 = parent->generic_class;
  if (D.25568 != 0B) goto <D.25569>; else goto <D.25570>;
  <D.25569>:
  D.25571 = parent->name;
  if (D.25571 == 0B) goto <D.25572>; else goto <D.25573>;
  <D.25572>:
  return;
  <D.25573>:
  <D.25570>:
  D.25574 = parent->marshalbyref;
  class->marshalbyref = D.25574;
  D.25575 = parent->contextbound;
  class->contextbound = D.25575;
  D.25576 = parent->delegate;
  class->delegate = D.25576;
  D.25554 = class->flags;
  D.25560 = D.25554 & 4096;
  if (D.25560 != 0) goto <D.25577>; else goto <D.25579>;
  <D.25579>:
  D.25580 = BIT_FIELD_REF <*parent, 64, 256>;
  D.25581 = D.25580 & 8589934592;
  if (D.25581 != 0) goto <D.25577>; else goto <D.25578>;
  <D.25577>:
  class->is_com_object = 1;
  <D.25578>:
  if (system_namespace != 0) goto <D.25582>; else goto <D.25583>;
  <D.25582>:
  D.25545 = class->name;
  D.25584 = *D.25545;
  if (D.25584 == 77) goto <D.25585>; else goto <D.25586>;
  <D.25585>:
  D.25545 = class->name;
  D.25587 = strcmp (D.25545, "MarshalByRefObject");
  if (D.25587 == 0) goto <D.25588>; else goto <D.25589>;
  <D.25588>:
  class->marshalbyref = 1;
  <D.25589>:
  <D.25586>:
  D.25545 = class->name;
  D.25584 = *D.25545;
  if (D.25584 == 67) goto <D.25590>; else goto <D.25591>;
  <D.25590>:
  D.25545 = class->name;
  D.25592 = strcmp (D.25545, "ContextBoundObject");
  if (D.25592 == 0) goto <D.25593>; else goto <D.25594>;
  <D.25593>:
  class->contextbound = 1;
  <D.25594>:
  <D.25591>:
  D.25545 = class->name;
  D.25584 = *D.25545;
  if (D.25584 == 68) goto <D.25595>; else goto <D.25596>;
  <D.25595>:
  D.25545 = class->name;
  D.25597 = strcmp (D.25545, "Delegate");
  if (D.25597 == 0) goto <D.25598>; else goto <D.25599>;
  <D.25598>:
  class->delegate = 1;
  <D.25599>:
  <D.25596>:
  <D.25583>:
  D.25602 = class->parent;
  D.25603 = BIT_FIELD_REF <*D.25602, 64, 256>;
  D.25604 = D.25603 & 576460752303423488;
  if (D.25604 != 0) goto <D.25600>; else goto <D.25605>;
  <D.25605>:
  D.25602 = class->parent;
  D.25606 = D.25602->image;
  D.25607 = mono_is_corlib_image (D.25606);
  if (D.25607 != 0) goto <D.25608>; else goto <D.25601>;
  <D.25608>:
  D.25602 = class->parent;
  D.25609 = D.25602->name;
  D.25610 = strcmp (D.25609, "ValueType");
  if (D.25610 == 0) goto <D.25611>; else goto <D.25601>;
  <D.25611>:
  D.25602 = class->parent;
  D.25612 = D.25602->name_space;
  D.25613 = strcmp (D.25612, "System");
  if (D.25613 == 0) goto <D.25600>; else goto <D.25601>;
  <D.25600>:
  class->valuetype = 1;
  <D.25601>:
  D.25602 = class->parent;
  D.25606 = D.25602->image;
  D.25614 = mono_is_corlib_image (D.25606);
  if (D.25614 != 0) goto <D.25615>; else goto <D.25616>;
  <D.25615>:
  D.25602 = class->parent;
  D.25609 = D.25602->name;
  D.25617 = strcmp (D.25609, "Enum");
  if (D.25617 == 0) goto <D.25618>; else goto <D.25619>;
  <D.25618>:
  D.25602 = class->parent;
  D.25612 = D.25602->name_space;
  D.25620 = strcmp (D.25612, "System");
  if (D.25620 == 0) goto <D.25621>; else goto <D.25622>;
  <D.25621>:
  class->enumtype = 1;
  D.25623 = class->enumtype;
  class->valuetype = D.25623;
  <D.25622>:
  <D.25619>:
  <D.25616>:
  goto <D.25553>;
  <D.25552>:
  D.25554 = class->flags;
  D.25560 = D.25554 & 4096;
  if (D.25560 != 0) goto <D.25624>; else goto <D.25625>;
  <D.25624>:
  init_com_from_comimport (class);
  <D.25625>:
  class->parent = 0B;
  <D.25553>:
}


init_com_from_comimport (struct MonoClass * class)
{
  <unnamed type> D.25627;
  struct MonoImage * D.25630;
  int D.25631;

  D.25627 = mono_security_get_mode ();
  if (D.25627 == 1) goto <D.25628>; else goto <D.25629>;
  <D.25628>:
  D.25630 = class->image;
  D.25631 = mono_security_core_clr_determine_platform_image (D.25630);
  if (D.25631 == 0) goto <D.25632>; else goto <D.25633>;
  <D.25632>:
  mono_class_set_failure (class, 7, 0B);
  return;
  <D.25633>:
  <D.25629>:
}


__attribute__((visibility ("hidden")))
mono_class_setup_supertypes (struct MonoClass * class)
{
  struct MonoClass * D.25637;
  struct MonoClass * * D.25640;
  short unsigned int D.25645;
  short unsigned int D.25646;
  int iftmp.163;
  short unsigned int D.25649;
  unsigned int ms.164;
  unsigned int D.25654;
  int D.25655;
  long unsigned int D.25658;
  long unsigned int D.25659;
  sizetype D.25660;
  struct MonoClass * * D.25661;
  long unsigned int D.25662;
  long unsigned int D.25663;
  int ms;
  struct MonoClass * * supertypes;

  {
    void * __tmp;

    __tmp = class->supertypes;
    supertypes = __tmp;
  }
  if (supertypes != 0B) goto <D.25635>; else goto <D.25636>;
  <D.25635>:
  return;
  <D.25636>:
  D.25637 = class->parent;
  if (D.25637 != 0B) goto <D.25638>; else goto <D.25639>;
  <D.25638>:
  D.25637 = class->parent;
  D.25640 = D.25637->supertypes;
  if (D.25640 == 0B) goto <D.25641>; else goto <D.25642>;
  <D.25641>:
  D.25637 = class->parent;
  mono_class_setup_supertypes (D.25637);
  <D.25642>:
  <D.25639>:
  D.25637 = class->parent;
  if (D.25637 != 0B) goto <D.25643>; else goto <D.25644>;
  <D.25643>:
  D.25637 = class->parent;
  D.25645 = D.25637->idepth;
  D.25646 = D.25645 + 1;
  class->idepth = D.25646;
  goto <D.25647>;
  <D.25644>:
  class->idepth = 1;
  <D.25647>:
  D.25649 = class->idepth;
  if (D.25649 > 5) goto <D.25650>; else goto <D.25651>;
  <D.25650>:
  D.25649 = class->idepth;
  iftmp.163 = (int) D.25649;
  goto <D.25652>;
  <D.25651>:
  iftmp.163 = 6;
  <D.25652>:
  ms = iftmp.163;
  ms.164 = (unsigned int) ms;
  D.25654 = ms.164 * 8;
  D.25655 = (int) D.25654;
  supertypes = mono_class_alloc0 (class, D.25655);
  D.25637 = class->parent;
  if (D.25637 != 0B) goto <D.25656>; else goto <D.25657>;
  <D.25656>:
  D.25649 = class->idepth;
  D.25658 = (long unsigned int) D.25649;
  D.25659 = D.25658 * 8;
  D.25660 = D.25659 + 18446744073709551608;
  D.25661 = supertypes + D.25660;
  *D.25661 = class;
  D.25637 = class->parent;
  D.25640 = D.25637->supertypes;
  D.25637 = class->parent;
  D.25645 = D.25637->idepth;
  D.25662 = (long unsigned int) D.25645;
  D.25663 = D.25662 * 8;
  memcpy (supertypes, D.25640, D.25663);
  goto <D.25664>;
  <D.25657>:
  *supertypes = class;
  <D.25664>:
  class->supertypes = supertypes;
}


__attribute__((visibility ("hidden")))
mono_class_is_nullable (struct MonoClass * klass)
{
  gboolean D.25666;
  int iftmp.165;
  struct MonoGenericClass * D.25670;
  struct MonoClass * D.25672;
  struct MonoClass * D.25673;

  D.25670 = klass->generic_class;
  if (D.25670 != 0B) goto <D.25671>; else goto <D.25668>;
  <D.25671>:
  D.25670 = klass->generic_class;
  D.25672 = D.25670->container_class;
  D.25673 = mono_defaults.generic_nullable_class;
  if (D.25672 == D.25673) goto <D.25674>; else goto <D.25668>;
  <D.25674>:
  iftmp.165 = 1;
  goto <D.25669>;
  <D.25668>:
  iftmp.165 = 0;
  <D.25669>:
  D.25666 = iftmp.165;
  return D.25666;
}


__attribute__((visibility ("hidden")))
mono_class_get_nullable_param (struct MonoClass * klass)
{
  int D.25676;
  _Bool D.25677;
  long int D.25678;
  long int D.25679;
  struct MonoClass * D.25682;
  struct MonoGenericClass * D.25683;
  struct MonoGenericInst * D.25684;
  struct MonoType * D.25685;

  D.25676 = mono_class_is_nullable (klass);
  D.25677 = D.25676 == 0;
  D.25678 = (long int) D.25677;
  D.25679 = __builtin_expect (D.25678, 0);
  if (D.25679 != 0) goto <D.25680>; else goto <D.25681>;
  <D.25680>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "class.c", 5807, "mono_class_is_nullable (klass)");
  <D.25681>:
  D.25683 = klass->generic_class;
  D.25684 = D.25683->context.class_inst;
  D.25685 = D.25684->type_argv[0];
  D.25682 = mono_class_from_mono_type (D.25685);
  return D.25682;
}


__attribute__((visibility ("hidden")))
mono_generic_class_get_class (struct MonoGenericClass * gclass)
{
  struct MonoClass * D.25687;
  struct MonoClass * D.25690;
  struct MonoImageSet * D.25693;
  int record_gclass_instantiation.166;
  struct GSList * gclass_recorded_list.167;
  struct GSList * D.25698;
  struct MonoClass * D.25699;
  const char * D.25702;
  const char * D.25703;
  struct MonoImage * D.25704;
  unsigned int D.25705;
  unsigned int D.25706;
  unsigned int D.25707;
  unsigned char D.25708;
  struct MonoGenericClass * D.25709;
  <unnamed-unsigned:1> D.25710;
  <unnamed-unsigned:1> D.25711;
  struct MonoClass * D.25712;
  int D.25713;
  struct MonoClass * D.25716;
  long unsigned int D.25717;
  long unsigned int D.25718;
  long unsigned int D.25721;
  long unsigned int D.25722;
  int D.25725;
  int D.25726;
  unsigned int inflated_classes.168;
  unsigned int D.25728;
  unsigned int inflated_classes_size.169;
  unsigned int D.25730;
  struct MonoClass * klass;
  struct MonoClass * gklass;

  D.25687 = gclass->cached_class;
  if (D.25687 != 0B) goto <D.25688>; else goto <D.25689>;
  <D.25688>:
  D.25690 = gclass->cached_class;
  return D.25690;
  <D.25689>:
  mono_loader_lock ();
  D.25687 = gclass->cached_class;
  if (D.25687 != 0B) goto <D.25691>; else goto <D.25692>;
  <D.25691>:
  mono_loader_unlock ();
  D.25690 = gclass->cached_class;
  return D.25690;
  <D.25692>:
  D.25693 = gclass->owner;
  klass = mono_image_set_alloc0 (D.25693, 272);
  gklass = gclass->container_class;
  record_gclass_instantiation.166 = record_gclass_instantiation;
  if (record_gclass_instantiation.166 > 0) goto <D.25695>; else goto <D.25696>;
  <D.25695>:
  gclass_recorded_list.167 = gclass_recorded_list;
  D.25698 = monoeg_g_slist_append (gclass_recorded_list.167, klass);
  gclass_recorded_list = D.25698;
  <D.25696>:
  D.25699 = gklass->nested_in;
  if (D.25699 != 0B) goto <D.25700>; else goto <D.25701>;
  <D.25700>:
  D.25699 = gklass->nested_in;
  klass->nested_in = D.25699;
  <D.25701>:
  D.25702 = gklass->name;
  klass->name = D.25702;
  D.25703 = gklass->name_space;
  klass->name_space = D.25703;
  mono_profiler_class_event (klass, 0);
  D.25704 = gklass->image;
  klass->image = D.25704;
  D.25705 = gklass->flags;
  klass->flags = D.25705;
  D.25706 = gklass->type_token;
  klass->type_token = D.25706;
  D.25707 = gklass->field.count;
  klass->field.count = D.25707;
  klass->is_inflated = 1;
  klass->generic_class = gclass;
  klass->byval_arg.type = 21;
  D.25708 = klass->byval_arg.type;
  klass->this_arg.type = D.25708;
  klass->byval_arg.data.generic_class = gclass;
  D.25709 = klass->byval_arg.data.generic_class;
  klass->this_arg.data.generic_class = D.25709;
  klass->this_arg.byref = 1;
  D.25710 = gklass->enumtype;
  klass->enumtype = D.25710;
  D.25711 = gklass->valuetype;
  klass->valuetype = D.25711;
  klass->element_class = klass;
  D.25712 = klass->element_class;
  klass->cast_class = D.25712;
  D.25713 = mono_class_is_nullable (klass);
  if (D.25713 != 0) goto <D.25714>; else goto <D.25715>;
  <D.25714>:
  D.25716 = mono_class_get_nullable_param (klass);
  klass->element_class = D.25716;
  D.25712 = klass->element_class;
  klass->cast_class = D.25712;
  <D.25715>:
  mono_generic_class_setup_parent (klass, gklass);
  D.25717 = BIT_FIELD_REF <*gclass, 64, 192>;
  D.25718 = D.25717 & 9223372036854775808;
  if (D.25718 != 0) goto <D.25719>; else goto <D.25720>;
  <D.25719>:
  klass->inited = 1;
  mono_class_setup_supertypes (klass);
  D.25721 = BIT_FIELD_REF <*klass, 64, 256>;
  D.25722 = D.25721 & 576460752303423488;
  if (D.25722 != 0) goto <D.25723>; else goto <D.25724>;
  <D.25723>:
  D.25725 = gklass->instance_size;
  klass->instance_size = D.25725;
  D.25726 = gklass->sizes.class_size;
  klass->sizes.class_size = D.25726;
  mono_memory_barrier ();
  klass->size_inited = 1;
  <D.25724>:
  <D.25720>:
  mono_memory_barrier ();
  gclass->cached_class = klass;
  mono_profiler_class_loaded (klass, 0);
  inflated_classes.168 = inflated_classes;
  D.25728 = inflated_classes.168 + 1;
  inflated_classes = D.25728;
  inflated_classes_size.169 = inflated_classes_size;
  D.25730 = inflated_classes_size.169 + 272;
  inflated_classes_size = D.25730;
  mono_loader_unlock ();
  D.25690 = klass;
  return D.25690;
}


mono_class_from_generic_parameter (struct MonoGenericParam * param, struct MonoImage * image, gboolean is_mvar)
{
  struct MonoGenericParamInfo * iftmp.170;
  struct MonoGenericContainer * D.25735;
  struct MonoClass * D.25739;
  struct MonoClass * D.25742;
  struct MonoImage * iftmp.171;
  struct MonoClass * D.25756;
  struct MonoImage * iftmp.172;
  struct MonoGenericContainer * container;
  struct MonoGenericParamInfo * pinfo;
  struct MonoClass * klass;

  container = param->owner;
  mono_loader_lock ();
  if (container != 0B) goto <D.25732>; else goto <D.25733>;
  <D.25732>:
  D.25735 = param->owner;
  if (D.25735 != 0B) goto <D.25736>; else goto <D.25737>;
  <D.25736>:
  iftmp.170 = &MEM[(struct MonoGenericParamFull *)param].info;
  goto <D.25738>;
  <D.25737>:
  iftmp.170 = 0B;
  <D.25738>:
  pinfo = iftmp.170;
  D.25739 = pinfo->pklass;
  if (D.25739 != 0B) goto <D.25740>; else goto <D.25741>;
  <D.25740>:
  mono_loader_unlock ();
  D.25742 = pinfo->pklass;
  return D.25742;
  <D.25741>:
  goto <D.25743>;
  <D.25733>:
  pinfo = 0B;
  image = 0B;
  klass = get_anon_gparam_class (param, is_mvar);
  if (klass != 0B) goto <D.25744>; else goto <D.25745>;
  <D.25744>:
  mono_loader_unlock ();
  D.25742 = klass;
  return D.25742;
  <D.25745>:
  <D.25743>:
  if (image == 0B) goto <D.25746>; else goto <D.25747>;
  <D.25746>:
  if (container != 0B) goto <D.25748>; else goto <D.25749>;
  <D.25748>:
  if (is_mvar != 0) goto <D.25750>; else goto <D.25751>;
  <D.25750>:
  {
    struct MonoMethod * method;

    method = container->owner.method;
    if (method != 0B) goto <D.25755>; else goto <D.25753>;
    <D.25755>:
    D.25756 = method->klass;
    if (D.25756 != 0B) goto <D.25757>; else goto <D.25753>;
    <D.25757>:
    D.25756 = method->klass;
    iftmp.171 = D.25756->image;
    goto <D.25754>;
    <D.25753>:
    iftmp.171 = 0B;
    <D.25754>:
    image = iftmp.171;
  }
  goto <D.25758>;
  <D.25751>:
  {
    struct MonoClass * klass;

    klass = container->owner.klass;
    if (klass != 0B) goto <D.25760>; else goto <D.25761>;
    <D.25760>:
    iftmp.172 = klass->image;
    goto <D.25762>;
    <D.25761>:
    iftmp.172 = 0B;
    <D.25762>:
    image = iftmp.172;
  }
  <D.25758>:
  <D.25749>:
  <D.25747>:
  klass = make_generic_param_class (param, image, is_mvar, pinfo);
  mono_memory_barrier ();
  if (container != 0B) goto <D.25763>; else goto <D.25764>;
  <D.25763>:
  pinfo->pklass = klass;
  goto <D.25765>;
  <D.25764>:
  set_anon_gparam_class (param, is_mvar, klass);
  <D.25765>:
  mono_loader_unlock ();
  mono_profiler_class_loaded (klass, 0);
  D.25742 = klass;
  return D.25742;
}


get_anon_gparam_class (struct MonoGenericParam * param, gboolean is_mvar)
{
  short unsigned int D.25767;
  unsigned int D.25768;
  short unsigned int D.25769;
  unsigned int D.25770;
  unsigned int D.25771;
  unsigned int D.25772;
  _Bool D.25773;
  long int D.25774;
  long int D.25775;
  struct MonoClass * D.25782;
  struct MonoClass * iftmp.173;
  struct MonoClass * * D.25784;
  long unsigned int D.25787;
  long unsigned int D.25788;
  struct MonoClass * * D.25789;
  struct MonoClass * iftmp.174;
  struct MonoClass * * D.25792;
  struct MonoClass * * D.25795;
  struct GHashTable * iftmp.175;
  struct MonoClass * iftmp.176;
  long int D.25804;
  const void * D.25805;
  int n;
  struct MonoImage * image;
  struct GHashTable * ht;

  D.25767 = param->num;
  D.25768 = (unsigned int) D.25767;
  D.25769 = param->serial;
  D.25770 = (unsigned int) D.25769;
  D.25771 = D.25770 << 16;
  D.25772 = D.25768 | D.25771;
  n = (int) D.25772;
  image = param->image;
  D.25773 = image == 0B;
  D.25774 = (long int) D.25773;
  D.25775 = __builtin_expect (D.25774, 0);
  if (D.25775 != 0) goto <D.25776>; else goto <D.25777>;
  <D.25776>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "class.c", 6028, "image");
  <D.25777>:
  if (n <= 15) goto <D.25778>; else goto <D.25779>;
  <D.25778>:
  if (is_mvar != 0) goto <D.25780>; else goto <D.25781>;
  <D.25780>:
  D.25784 = image->mvar_cache_fast;
  if (D.25784 != 0B) goto <D.25785>; else goto <D.25786>;
  <D.25785>:
  D.25784 = image->mvar_cache_fast;
  D.25787 = (long unsigned int) n;
  D.25788 = D.25787 * 8;
  D.25789 = D.25784 + D.25788;
  iftmp.173 = *D.25789;
  goto <D.25790>;
  <D.25786>:
  iftmp.173 = 0B;
  <D.25790>:
  D.25782 = iftmp.173;
  return D.25782;
  <D.25781>:
  D.25792 = image->var_cache_fast;
  if (D.25792 != 0B) goto <D.25793>; else goto <D.25794>;
  <D.25793>:
  D.25792 = image->var_cache_fast;
  D.25787 = (long unsigned int) n;
  D.25788 = D.25787 * 8;
  D.25795 = D.25792 + D.25788;
  iftmp.174 = *D.25795;
  goto <D.25796>;
  <D.25794>:
  iftmp.174 = 0B;
  <D.25796>:
  D.25782 = iftmp.174;
  return D.25782;
  <D.25779>:
  if (is_mvar != 0) goto <D.25798>; else goto <D.25799>;
  <D.25798>:
  iftmp.175 = image->mvar_cache_slow;
  goto <D.25800>;
  <D.25799>:
  iftmp.175 = image->var_cache_slow;
  <D.25800>:
  ht = iftmp.175;
  if (ht != 0B) goto <D.25802>; else goto <D.25803>;
  <D.25802>:
  D.25804 = (long int) n;
  D.25805 = (const void *) D.25804;
  iftmp.176 = monoeg_g_hash_table_lookup (ht, D.25805);
  goto <D.25806>;
  <D.25803>:
  iftmp.176 = 0B;
  <D.25806>:
  D.25782 = iftmp.176;
  return D.25782;
}


make_generic_param_class (struct MonoGenericParam * param, struct MonoImage * image, gboolean is_mvar, struct MonoGenericParamInfo * pinfo)
{
  unsigned int classes_size.177;
  unsigned int D.25811;
  const char * D.25814;
  short unsigned int D.25816;
  void * D.25817;
  const char * D.25818;
  const char * iftmp.178;
  struct MonoClass * D.25827;
  const char * iftmp.179;
  struct MonoClass * D.25838;
  struct MonoClass * * D.25842;
  struct MonoClass * D.25843;
  unsigned int D.25844;
  unsigned int D.25845;
  unsigned char D.25847;
  short unsigned int D.25853;
  int D.25854;
  int D.25855;
  struct MonoImage * D.25857;
  struct MonoClass * D.25858;
  struct MonoClass * D.25859;
  int D.25860;
  short unsigned int D.25863;
  short unsigned int D.25864;
  short unsigned int D.25865;
  long unsigned int D.25866;
  unsigned int D.25867;
  unsigned int D.25868;
  void * D.25869;
  struct MonoClass * * D.25870;
  int D.25871;
  long unsigned int D.25872;
  long unsigned int D.25873;
  struct MonoClass * * D.25874;
  long unsigned int D.25875;
  long unsigned int D.25876;
  struct MonoClass * * D.25877;
  struct MonoClass * D.25878;
  struct MonoClass * D.25879;
  unsigned char iftmp.180;
  unsigned char D.25884;
  struct MonoGenericParam * D.25885;
  int iftmp.181;
  unsigned int D.25889;
  struct MonoClass * D.25893;
  unsigned char D.25894;
  gchar * D.25897;
  int D.25899;
  struct MonoClass * D.25900;
  struct MonoClass * klass;
  struct MonoClass * * ptr;
  int count;
  int pos;
  int i;
  struct MonoGenericContainer * container;

  container = param->owner;
  if (image == 0B) goto <D.25808>; else goto <D.25809>;
  <D.25808>:
  image = mono_defaults.corlib;
  <D.25809>:
  klass = mono_image_alloc0 (image, 272);
  classes_size.177 = classes_size;
  D.25811 = classes_size.177 + 272;
  classes_size = D.25811;
  if (pinfo != 0B) goto <D.25812>; else goto <D.25813>;
  <D.25812>:
  D.25814 = pinfo->name;
  klass->name = D.25814;
  goto <D.25815>;
  <D.25813>:
  {
    int n;

    D.25816 = param->num;
    n = (int) D.25816;
    D.25817 = mono_image_alloc0 (image, 16);
    klass->name = D.25817;
    D.25818 = klass->name;
    sprintf (D.25818, "%d", n);
  }
  <D.25815>:
  if (container != 0B) goto <D.25819>; else goto <D.25820>;
  <D.25819>:
  if (is_mvar != 0) goto <D.25821>; else goto <D.25822>;
  <D.25821>:
  {
    struct MonoMethod * omethod;

    omethod = container->owner.method;
    if (omethod != 0B) goto <D.25826>; else goto <D.25824>;
    <D.25826>:
    D.25827 = omethod->klass;
    if (D.25827 != 0B) goto <D.25828>; else goto <D.25824>;
    <D.25828>:
    D.25827 = omethod->klass;
    iftmp.178 = D.25827->name_space;
    goto <D.25825>;
    <D.25824>:
    iftmp.178 = "";
    <D.25825>:
    klass->name_space = iftmp.178;
  }
  goto <D.25829>;
  <D.25822>:
  {
    struct MonoClass * oklass;

    oklass = container->owner.klass;
    if (oklass != 0B) goto <D.25831>; else goto <D.25832>;
    <D.25831>:
    iftmp.179 = oklass->name_space;
    goto <D.25833>;
    <D.25832>:
    iftmp.179 = "";
    <D.25833>:
    klass->name_space = iftmp.179;
  }
  <D.25829>:
  goto <D.25834>;
  <D.25820>:
  klass->name_space = "";
  <D.25834>:
  mono_profiler_class_event (klass, 0);
  count = 0;
  if (pinfo != 0B) goto <D.25835>; else goto <D.25836>;
  <D.25835>:
  ptr = pinfo->constraints;
  goto <D.20264>;
  <D.20263>:
  ptr = ptr + 8;
  count = count + 1;
  <D.20264>:
  if (ptr != 0B) goto <D.25837>; else goto <D.20265>;
  <D.25837>:
  D.25838 = *ptr;
  if (D.25838 != 0B) goto <D.20263>; else goto <D.20265>;
  <D.20265>:
  <D.25836>:
  pos = 0;
  if (count > 0) goto <D.25841>; else goto <D.25839>;
  <D.25841>:
  D.25842 = pinfo->constraints;
  D.25843 = *D.25842;
  D.25844 = D.25843->flags;
  D.25845 = D.25844 & 32;
  if (D.25845 == 0) goto <D.25846>; else goto <D.25839>;
  <D.25846>:
  D.25842 = pinfo->constraints;
  D.25843 = *D.25842;
  D.25847 = D.25843->byval_arg.type;
  if (D.25847 != 19) goto <D.25848>; else goto <D.25839>;
  <D.25848>:
  D.25842 = pinfo->constraints;
  D.25843 = *D.25842;
  D.25847 = D.25843->byval_arg.type;
  if (D.25847 != 30) goto <D.25849>; else goto <D.25839>;
  <D.25849>:
  D.25842 = pinfo->constraints;
  D.25843 = *D.25842;
  klass->parent = D.25843;
  pos = pos + 1;
  goto <D.25840>;
  <D.25839>:
  if (pinfo != 0B) goto <D.25852>; else goto <D.25850>;
  <D.25852>:
  D.25853 = pinfo->flags;
  D.25854 = (int) D.25853;
  D.25855 = D.25854 & 8;
  if (D.25855 != 0) goto <D.25856>; else goto <D.25850>;
  <D.25856>:
  D.25857 = mono_defaults.corlib;
  D.25858 = mono_class_from_name (D.25857, "System", "ValueType");
  klass->parent = D.25858;
  goto <D.25851>;
  <D.25850>:
  D.25859 = mono_defaults.object_class;
  klass->parent = D.25859;
  <D.25851>:
  <D.25840>:
  D.25860 = count - pos;
  if (D.25860 > 0) goto <D.25861>; else goto <D.25862>;
  <D.25861>:
  D.25863 = (short unsigned int) count;
  D.25864 = (short unsigned int) pos;
  D.25865 = D.25863 - D.25864;
  klass->interface_count = D.25865;
  D.25860 = count - pos;
  D.25866 = (long unsigned int) D.25860;
  D.25867 = (unsigned int) D.25866;
  D.25868 = D.25867 * 8;
  D.25869 = mono_image_alloc0 (image, D.25868);
  klass->interfaces = D.25869;
  klass->interfaces_inited = 1;
  i = pos;
  goto <D.20267>;
  <D.20266>:
  D.25870 = klass->interfaces;
  D.25871 = i - pos;
  D.25872 = (long unsigned int) D.25871;
  D.25873 = D.25872 * 8;
  D.25874 = D.25870 + D.25873;
  D.25842 = pinfo->constraints;
  D.25875 = (long unsigned int) i;
  D.25876 = D.25875 * 8;
  D.25877 = D.25842 + D.25876;
  D.25878 = *D.25877;
  *D.25874 = D.25878;
  i = i + 1;
  <D.20267>:
  if (i < count) goto <D.20266>; else goto <D.20268>;
  <D.20268>:
  <D.25862>:
  klass->image = image;
  klass->inited = 1;
  klass->element_class = klass;
  D.25879 = klass->element_class;
  klass->cast_class = D.25879;
  klass->flags = 1;
  if (is_mvar != 0) goto <D.25881>; else goto <D.25882>;
  <D.25881>:
  iftmp.180 = 30;
  goto <D.25883>;
  <D.25882>:
  iftmp.180 = 19;
  <D.25883>:
  klass->byval_arg.type = iftmp.180;
  D.25884 = klass->byval_arg.type;
  klass->this_arg.type = D.25884;
  klass->byval_arg.data.generic_param = param;
  D.25885 = klass->byval_arg.data.generic_param;
  klass->this_arg.data.generic_param = D.25885;
  klass->this_arg.byref = 1;
  if (pinfo != 0B) goto <D.25887>; else goto <D.25888>;
  <D.25887>:
  D.25889 = pinfo->token;
  iftmp.181 = (int) D.25889;
  goto <D.25890>;
  <D.25888>:
  iftmp.181 = 0;
  <D.25890>:
  klass->sizes.generic_param_token = iftmp.181;
  klass->min_align = 1;
  klass->instance_size = 8;
  mono_memory_barrier ();
  klass->size_inited = 1;
  mono_class_setup_supertypes (klass);
  D.25860 = count - pos;
  if (D.25860 > 0) goto <D.25891>; else goto <D.25892>;
  <D.25891>:
  D.25893 = klass->parent;
  mono_class_setup_vtable (D.25893);
  D.25893 = klass->parent;
  D.25894 = D.25893->exception_type;
  if (D.25894 != 0) goto <D.25895>; else goto <D.25896>;
  <D.25895>:
  D.25897 = monoeg_strdup ("Failed to setup parent interfaces");
  mono_class_set_failure (klass, 7, D.25897);
  goto <D.25898>;
  <D.25896>:
  D.25893 = klass->parent;
  D.25899 = D.25893->vtable_size;
  setup_interface_offsets (klass, D.25899, 1);
  <D.25898>:
  <D.25892>:
  D.25900 = klass;
  return D.25900;
}


__attribute__((__artificial__, __gnu_inline__, __always_inline__, __leaf__, __nothrow__))
sprintf (char * restrict __s, const char * restrict __fmt)
{
  int D.25902;
  long unsigned int D.25903;

  D.25903 = __builtin_object_size (__s, 1);
  D.25902 = __builtin___sprintf_chk (__s, 1, D.25903, __fmt, __builtin_va_arg_pack ());
  return D.25902;
}


set_anon_gparam_class (struct MonoGenericParam * param, gboolean is_mvar, struct MonoClass * klass)
{
  short unsigned int D.25905;
  unsigned int D.25906;
  short unsigned int D.25907;
  unsigned int D.25908;
  unsigned int D.25909;
  unsigned int D.25910;
  _Bool D.25911;
  long int D.25912;
  long int D.25913;
  struct MonoClass * * D.25920;
  void * D.25923;
  long unsigned int D.25924;
  long unsigned int D.25925;
  struct MonoClass * * D.25926;
  struct MonoClass * * D.25928;
  void * D.25931;
  struct MonoClass * * D.25932;
  struct GHashTable * iftmp.182;
  struct GHashTable * iftmp.183;
  long int D.25948;
  void * D.25949;
  int n;
  struct MonoImage * image;
  struct GHashTable * ht;

  D.25905 = param->num;
  D.25906 = (unsigned int) D.25905;
  D.25907 = param->serial;
  D.25908 = (unsigned int) D.25907;
  D.25909 = D.25908 << 16;
  D.25910 = D.25906 | D.25909;
  n = (int) D.25910;
  image = param->image;
  D.25911 = image == 0B;
  D.25912 = (long int) D.25911;
  D.25913 = __builtin_expect (D.25912, 0);
  if (D.25913 != 0) goto <D.25914>; else goto <D.25915>;
  <D.25914>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "class.c", 6051, "image");
  <D.25915>:
  if (n <= 15) goto <D.25916>; else goto <D.25917>;
  <D.25916>:
  if (is_mvar != 0) goto <D.25918>; else goto <D.25919>;
  <D.25918>:
  D.25920 = image->mvar_cache_fast;
  if (D.25920 == 0B) goto <D.25921>; else goto <D.25922>;
  <D.25921>:
  D.25923 = mono_image_alloc0 (image, 128);
  image->mvar_cache_fast = D.25923;
  <D.25922>:
  D.25920 = image->mvar_cache_fast;
  D.25924 = (long unsigned int) n;
  D.25925 = D.25924 * 8;
  D.25926 = D.25920 + D.25925;
  *D.25926 = klass;
  goto <D.25927>;
  <D.25919>:
  D.25928 = image->var_cache_fast;
  if (D.25928 == 0B) goto <D.25929>; else goto <D.25930>;
  <D.25929>:
  D.25931 = mono_image_alloc0 (image, 128);
  image->var_cache_fast = D.25931;
  <D.25930>:
  D.25928 = image->var_cache_fast;
  D.25924 = (long unsigned int) n;
  D.25925 = D.25924 * 8;
  D.25932 = D.25928 + D.25925;
  *D.25932 = klass;
  <D.25927>:
  return;
  <D.25917>:
  if (is_mvar != 0) goto <D.25934>; else goto <D.25935>;
  <D.25934>:
  iftmp.182 = image->mvar_cache_slow;
  goto <D.25936>;
  <D.25935>:
  iftmp.182 = image->var_cache_slow;
  <D.25936>:
  ht = iftmp.182;
  if (ht == 0B) goto <D.25937>; else goto <D.25938>;
  <D.25937>:
  mono_loader_lock ();
  if (is_mvar != 0) goto <D.25940>; else goto <D.25941>;
  <D.25940>:
  iftmp.183 = image->mvar_cache_slow;
  goto <D.25942>;
  <D.25941>:
  iftmp.183 = image->var_cache_slow;
  <D.25942>:
  ht = iftmp.183;
  if (ht == 0B) goto <D.25943>; else goto <D.25944>;
  <D.25943>:
  ht = monoeg_g_hash_table_new (0B, 0B);
  mono_memory_barrier ();
  if (is_mvar != 0) goto <D.25945>; else goto <D.25946>;
  <D.25945>:
  image->mvar_cache_slow = ht;
  goto <D.25947>;
  <D.25946>:
  image->var_cache_slow = ht;
  <D.25947>:
  <D.25944>:
  mono_loader_unlock ();
  <D.25938>:
  D.25948 = (long int) n;
  D.25949 = (void *) D.25948;
  monoeg_g_hash_table_insert_replace (ht, D.25949, klass, 0);
}


mono_ptr_class_get (struct MonoType * type)
{
  struct GHashTable * D.25951;
  struct GHashTable * D.25954;
  struct MonoClass * D.25957;
  unsigned int classes_size.184;
  unsigned int D.25959;
  const char * D.25960;
  const char * D.25961;
  char * D.25962;
  struct MonoImage * D.25963;
  unsigned int D.25964;
  unsigned int D.25965;
  struct MonoClass * D.25966;
  unsigned char D.25967;
  struct MonoType * D.25968;
  struct MonoType * D.25969;
  struct MonoClass * result;
  struct MonoClass * el_class;
  struct MonoImage * image;
  char * name;

  el_class = mono_class_from_mono_type (type);
  image = el_class->image;
  mono_loader_lock ();
  D.25951 = image->ptr_cache;
  if (D.25951 == 0B) goto <D.25952>; else goto <D.25953>;
  <D.25952>:
  D.25954 = monoeg_g_hash_table_new (mono_aligned_addr_hash, 0B);
  image->ptr_cache = D.25954;
  <D.25953>:
  D.25951 = image->ptr_cache;
  result = monoeg_g_hash_table_lookup (D.25951, el_class);
  if (result != 0B) goto <D.25955>; else goto <D.25956>;
  <D.25955>:
  mono_loader_unlock ();
  D.25957 = result;
  return D.25957;
  <D.25956>:
  result = mono_image_alloc0 (image, 272);
  classes_size.184 = classes_size;
  D.25959 = classes_size.184 + 272;
  classes_size = D.25959;
  result->parent = 0B;
  D.25960 = el_class->name_space;
  result->name_space = D.25960;
  D.25961 = el_class->name;
  name = monoeg_g_strdup_printf ("%s*", D.25961);
  D.25962 = mono_image_strdup (image, name);
  result->name = D.25962;
  monoeg_g_free (name);
  mono_profiler_class_event (result, 0);
  D.25963 = el_class->image;
  result->image = D.25963;
  result->inited = 1;
  D.25964 = el_class->flags;
  D.25965 = D.25964 & 7;
  result->flags = D.25965;
  result->instance_size = 8;
  result->element_class = el_class;
  D.25966 = result->element_class;
  result->cast_class = D.25966;
  result->blittable = 1;
  result->byval_arg.type = 15;
  D.25967 = result->byval_arg.type;
  result->this_arg.type = D.25967;
  D.25966 = result->element_class;
  D.25968 = &D.25966->byval_arg;
  result->byval_arg.data.type = D.25968;
  D.25969 = result->byval_arg.data.type;
  result->this_arg.data.type = D.25969;
  result->this_arg.byref = 1;
  mono_class_setup_supertypes (result);
  D.25951 = image->ptr_cache;
  monoeg_g_hash_table_insert_replace (D.25951, el_class, result, 0);
  mono_loader_unlock ();
  mono_profiler_class_loaded (result, 0);
  D.25957 = result;
  return D.25957;
}


mono_class_from_mono_type (struct MonoType * type)
{
  unsigned char D.25971;
  int D.25972;
  struct MonoClass * D.25973;
  struct MonoClass * iftmp.185;
  struct MonoClass * D.25975;
  struct MonoClass * iftmp.186;
  struct MonoClass * iftmp.187;
  struct MonoClass * iftmp.188;
  struct MonoClass * iftmp.189;
  struct MonoClass * iftmp.190;
  struct MonoClass * iftmp.191;
  struct MonoClass * iftmp.192;
  struct MonoClass * iftmp.193;
  struct MonoClass * iftmp.194;
  struct MonoClass * iftmp.195;
  struct MonoClass * iftmp.196;
  struct MonoClass * iftmp.197;
  struct MonoClass * iftmp.198;
  struct MonoClass * iftmp.199;
  struct MonoClass * iftmp.200;
  struct MonoClass * iftmp.201;
  struct MonoClass * iftmp.202;
  struct MonoArrayType * D.26047;
  struct MonoClass * D.26048;
  unsigned char D.26049;
  unsigned int D.26050;
  struct MonoType * D.26051;
  struct MonoMethodSignature * D.26052;
  struct MonoGenericClass * D.26053;
  struct MonoGenericParam * D.26054;

  D.25971 = type->type;
  D.25972 = (int) D.25971;
  switch (D.25972) <default: <D.20336>, case 1: <D.20310>, case 2: <D.20311>, case 3: <D.20312>, case 4: <D.20313>, case 5: <D.20314>, case 6: <D.20315>, case 7: <D.20316>, case 8: <D.20317>, case 9: <D.20318>, case 10: <D.20321>, case 11: <D.20322>, case 12: <D.20323>, case 13: <D.20324>, case 14: <D.20325>, case 15: <D.20328>, case 17: <D.20332>, case 18: <D.20331>, case 19: <D.20334>, case 20: <D.20327>, case 21: <D.20333>, case 22: <D.20326>, case 24: <D.20319>, case 25: <D.20320>, case 27: <D.20329>, case 28: <D.20309>, case 29: <D.20330>, case 30: <D.20335>>
  <D.20309>:
  D.25975 = type->data.klass;
  if (D.25975 != 0B) goto <D.25976>; else goto <D.25977>;
  <D.25976>:
  iftmp.185 = type->data.klass;
  goto <D.25978>;
  <D.25977>:
  iftmp.185 = mono_defaults.object_class;
  <D.25978>:
  D.25973 = iftmp.185;
  return D.25973;
  <D.20310>:
  D.25975 = type->data.klass;
  if (D.25975 != 0B) goto <D.25980>; else goto <D.25981>;
  <D.25980>:
  iftmp.186 = type->data.klass;
  goto <D.25982>;
  <D.25981>:
  iftmp.186 = mono_defaults.void_class;
  <D.25982>:
  D.25973 = iftmp.186;
  return D.25973;
  <D.20311>:
  D.25975 = type->data.klass;
  if (D.25975 != 0B) goto <D.25984>; else goto <D.25985>;
  <D.25984>:
  iftmp.187 = type->data.klass;
  goto <D.25986>;
  <D.25985>:
  iftmp.187 = mono_defaults.boolean_class;
  <D.25986>:
  D.25973 = iftmp.187;
  return D.25973;
  <D.20312>:
  D.25975 = type->data.klass;
  if (D.25975 != 0B) goto <D.25988>; else goto <D.25989>;
  <D.25988>:
  iftmp.188 = type->data.klass;
  goto <D.25990>;
  <D.25989>:
  iftmp.188 = mono_defaults.char_class;
  <D.25990>:
  D.25973 = iftmp.188;
  return D.25973;
  <D.20313>:
  D.25975 = type->data.klass;
  if (D.25975 != 0B) goto <D.25992>; else goto <D.25993>;
  <D.25992>:
  iftmp.189 = type->data.klass;
  goto <D.25994>;
  <D.25993>:
  iftmp.189 = mono_defaults.sbyte_class;
  <D.25994>:
  D.25973 = iftmp.189;
  return D.25973;
  <D.20314>:
  D.25975 = type->data.klass;
  if (D.25975 != 0B) goto <D.25996>; else goto <D.25997>;
  <D.25996>:
  iftmp.190 = type->data.klass;
  goto <D.25998>;
  <D.25997>:
  iftmp.190 = mono_defaults.byte_class;
  <D.25998>:
  D.25973 = iftmp.190;
  return D.25973;
  <D.20315>:
  D.25975 = type->data.klass;
  if (D.25975 != 0B) goto <D.26000>; else goto <D.26001>;
  <D.26000>:
  iftmp.191 = type->data.klass;
  goto <D.26002>;
  <D.26001>:
  iftmp.191 = mono_defaults.int16_class;
  <D.26002>:
  D.25973 = iftmp.191;
  return D.25973;
  <D.20316>:
  D.25975 = type->data.klass;
  if (D.25975 != 0B) goto <D.26004>; else goto <D.26005>;
  <D.26004>:
  iftmp.192 = type->data.klass;
  goto <D.26006>;
  <D.26005>:
  iftmp.192 = mono_defaults.uint16_class;
  <D.26006>:
  D.25973 = iftmp.192;
  return D.25973;
  <D.20317>:
  D.25975 = type->data.klass;
  if (D.25975 != 0B) goto <D.26008>; else goto <D.26009>;
  <D.26008>:
  iftmp.193 = type->data.klass;
  goto <D.26010>;
  <D.26009>:
  iftmp.193 = mono_defaults.int32_class;
  <D.26010>:
  D.25973 = iftmp.193;
  return D.25973;
  <D.20318>:
  D.25975 = type->data.klass;
  if (D.25975 != 0B) goto <D.26012>; else goto <D.26013>;
  <D.26012>:
  iftmp.194 = type->data.klass;
  goto <D.26014>;
  <D.26013>:
  iftmp.194 = mono_defaults.uint32_class;
  <D.26014>:
  D.25973 = iftmp.194;
  return D.25973;
  <D.20319>:
  D.25975 = type->data.klass;
  if (D.25975 != 0B) goto <D.26016>; else goto <D.26017>;
  <D.26016>:
  iftmp.195 = type->data.klass;
  goto <D.26018>;
  <D.26017>:
  iftmp.195 = mono_defaults.int_class;
  <D.26018>:
  D.25973 = iftmp.195;
  return D.25973;
  <D.20320>:
  D.25975 = type->data.klass;
  if (D.25975 != 0B) goto <D.26020>; else goto <D.26021>;
  <D.26020>:
  iftmp.196 = type->data.klass;
  goto <D.26022>;
  <D.26021>:
  iftmp.196 = mono_defaults.uint_class;
  <D.26022>:
  D.25973 = iftmp.196;
  return D.25973;
  <D.20321>:
  D.25975 = type->data.klass;
  if (D.25975 != 0B) goto <D.26024>; else goto <D.26025>;
  <D.26024>:
  iftmp.197 = type->data.klass;
  goto <D.26026>;
  <D.26025>:
  iftmp.197 = mono_defaults.int64_class;
  <D.26026>:
  D.25973 = iftmp.197;
  return D.25973;
  <D.20322>:
  D.25975 = type->data.klass;
  if (D.25975 != 0B) goto <D.26028>; else goto <D.26029>;
  <D.26028>:
  iftmp.198 = type->data.klass;
  goto <D.26030>;
  <D.26029>:
  iftmp.198 = mono_defaults.uint64_class;
  <D.26030>:
  D.25973 = iftmp.198;
  return D.25973;
  <D.20323>:
  D.25975 = type->data.klass;
  if (D.25975 != 0B) goto <D.26032>; else goto <D.26033>;
  <D.26032>:
  iftmp.199 = type->data.klass;
  goto <D.26034>;
  <D.26033>:
  iftmp.199 = mono_defaults.single_class;
  <D.26034>:
  D.25973 = iftmp.199;
  return D.25973;
  <D.20324>:
  D.25975 = type->data.klass;
  if (D.25975 != 0B) goto <D.26036>; else goto <D.26037>;
  <D.26036>:
  iftmp.200 = type->data.klass;
  goto <D.26038>;
  <D.26037>:
  iftmp.200 = mono_defaults.double_class;
  <D.26038>:
  D.25973 = iftmp.200;
  return D.25973;
  <D.20325>:
  D.25975 = type->data.klass;
  if (D.25975 != 0B) goto <D.26040>; else goto <D.26041>;
  <D.26040>:
  iftmp.201 = type->data.klass;
  goto <D.26042>;
  <D.26041>:
  iftmp.201 = mono_defaults.string_class;
  <D.26042>:
  D.25973 = iftmp.201;
  return D.25973;
  <D.20326>:
  D.25975 = type->data.klass;
  if (D.25975 != 0B) goto <D.26044>; else goto <D.26045>;
  <D.26044>:
  iftmp.202 = type->data.klass;
  goto <D.26046>;
  <D.26045>:
  iftmp.202 = mono_defaults.typed_reference_class;
  <D.26046>:
  D.25973 = iftmp.202;
  return D.25973;
  <D.20327>:
  D.26047 = type->data.array;
  D.26048 = D.26047->eklass;
  D.26047 = type->data.array;
  D.26049 = D.26047->rank;
  D.26050 = (unsigned int) D.26049;
  D.25973 = mono_bounded_array_class_get (D.26048, D.26050, 1);
  return D.25973;
  <D.20328>:
  D.26051 = type->data.type;
  D.25973 = mono_ptr_class_get (D.26051);
  return D.25973;
  <D.20329>:
  D.26052 = type->data.method;
  D.25973 = mono_fnptr_class_get (D.26052);
  return D.25973;
  <D.20330>:
  D.25975 = type->data.klass;
  D.25973 = mono_array_class_get (D.25975, 1);
  return D.25973;
  <D.20331>:
  <D.20332>:
  D.25973 = type->data.klass;
  return D.25973;
  <D.20333>:
  D.26053 = type->data.generic_class;
  D.25973 = mono_generic_class_get_class (D.26053);
  return D.25973;
  <D.20334>:
  D.26054 = type->data.generic_param;
  D.25973 = mono_class_from_generic_parameter (D.26054, 0B, 0);
  return D.25973;
  <D.20335>:
  D.26054 = type->data.generic_param;
  D.25973 = mono_class_from_generic_parameter (D.26054, 0B, 1);
  return D.25973;
  <D.20336>:
  D.25971 = type->type;
  D.25972 = (int) D.25971;
  monoeg_g_log (0B, 16, "mono_class_from_mono_type: implement me 0x%02x\n", D.25972);
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "class.c", 6305);
  D.25973 = 0B;
  return D.25973;
}


mono_fnptr_class_get (struct MonoMethodSignature * sig)
{
  struct GHashTable * ptr_hash.203;
  struct GHashTable * ptr_hash.204;
  struct MonoClass * D.26062;
  struct MonoImage * D.26063;
  struct MonoClass * D.26064;
  unsigned char D.26065;
  struct MonoMethodSignature * D.26066;
  struct MonoClass * result;
  static struct GHashTable * ptr_hash = 0B;

  mono_loader_lock ();
  ptr_hash.203 = ptr_hash;
  if (ptr_hash.203 == 0B) goto <D.26057>; else goto <D.26058>;
  <D.26057>:
  ptr_hash.204 = monoeg_g_hash_table_new (mono_aligned_addr_hash, 0B);
  ptr_hash = ptr_hash.204;
  <D.26058>:
  ptr_hash.203 = ptr_hash;
  result = monoeg_g_hash_table_lookup (ptr_hash.203, sig);
  if (result != 0B) goto <D.26060>; else goto <D.26061>;
  <D.26060>:
  mono_loader_unlock ();
  D.26062 = result;
  return D.26062;
  <D.26061>:
  result = monoeg_malloc0 (272);
  result->parent = 0B;
  result->name_space = "System";
  result->name = "MonoFNPtrFakeClass";
  mono_profiler_class_event (result, 0);
  D.26063 = mono_defaults.corlib;
  result->image = D.26063;
  result->inited = 1;
  result->flags = 0;
  result->instance_size = 8;
  result->element_class = result;
  D.26064 = result->element_class;
  result->cast_class = D.26064;
  result->blittable = 1;
  result->byval_arg.type = 27;
  D.26065 = result->byval_arg.type;
  result->this_arg.type = D.26065;
  result->byval_arg.data.method = sig;
  D.26066 = result->byval_arg.data.method;
  result->this_arg.data.method = D.26066;
  result->this_arg.byref = 1;
  result->blittable = 1;
  mono_class_setup_supertypes (result);
  ptr_hash.203 = ptr_hash;
  monoeg_g_hash_table_insert_replace (ptr_hash.203, sig, result, 0);
  mono_loader_unlock ();
  mono_profiler_class_loaded (result, 0);
  D.26062 = result;
  return D.26062;
}


mono_bounded_array_class_get (struct MonoClass * eclass, guint32 rank, gboolean bounded)
{
  _Bool D.26068;
  long int D.26069;
  long int D.26070;
  union mono_mutex_t * D.26079;
  _Bool D.26082;
  long int D.26083;
  long int D.26084;
  struct GHashTable * D.26087;
  struct GHashTable * D.26090;
  _Bool D.26093;
  long int D.26094;
  long int D.26095;
  struct MonoClass * D.26100;
  struct GHashTable * D.26101;
  struct GHashTable * D.26104;
  unsigned char D.26107;
  unsigned int D.26108;
  unsigned char D.26111;
  int D.26112;
  int iftmp.205;
  struct MonoAssembly * D.26122;
  unsigned char D.26124;
  const char * D.26126;
  int D.26128;
  long unsigned int D.26130;
  long unsigned int D.26131;
  const char * D.26134;
  const char * D.26135;
  long unsigned int D.26136;
  unsigned int nsize.206;
  unsigned int D.26138;
  unsigned int D.26139;
  long unsigned int D.26140;
  long unsigned int D.26141;
  sizetype D.26142;
  char * D.26143;
  sizetype D.26146;
  char * D.26147;
  unsigned int D.26148;
  long unsigned int D.26149;
  sizetype D.26152;
  char * D.26153;
  unsigned int bounded.207;
  unsigned int D.26155;
  sizetype D.26156;
  char * D.26157;
  unsigned int D.26158;
  sizetype D.26159;
  char * D.26160;
  char * D.26161;
  unsigned int classes_size.208;
  unsigned int D.26163;
  struct MonoClass * D.26164;
  int D.26165;
  unsigned char D.26169;
  long unsigned int D.26173;
  long unsigned int D.26174;
  struct MonoType * D.26176;
  unsigned int D.26180;
  long unsigned int D.26182;
  int iftmp.209;
  _Bool D.26188;
  long int D.26189;
  long int D.26190;
  int D.26193;
  struct MonoGenericClass * D.26194;
  long unsigned int D.26197;
  unsigned char D.26200;
  int iftmp.210;
  struct MonoType * D.26207;
  int D.26208;
  long unsigned int D.26210;
  unsigned char D.26211;
  <unnamed-unsigned:1> D.26212;
  unsigned char D.26213;
  struct MonoClass * D.26216;
  struct MonoClass * D.26218;
  unsigned char D.26219;
  int D.26220;
  struct MonoClass * D.26221;
  struct MonoClass * D.26222;
  struct MonoClass * D.26223;
  struct MonoClass * D.26224;
  unsigned char D.26230;
  struct MonoGenericContainer * D.26233;
  _Bool D.26240;
  long int D.26241;
  long int D.26242;
  _Bool D.26250;
  long int D.26251;
  long int D.26252;
  struct MonoImage * image;
  struct MonoClass * class;
  struct MonoClass * parent;
  struct GSList * list;
  struct GSList * rootlist;
  int nsize;
  char * name;
  gboolean corlib_type;

  parent = 0B;
  rootlist = 0B;
  corlib_type = 0;
  D.26068 = rank > 255;
  D.26069 = (long int) D.26068;
  D.26070 = __builtin_expect (D.26069, 0);
  if (D.26070 != 0) goto <D.26071>; else goto <D.26072>;
  <D.26071>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "class.c", 6386, "rank <= 255");
  <D.26072>:
  if (rank > 1) goto <D.26073>; else goto <D.26074>;
  <D.26073>:
  bounded = 0;
  <D.26074>:
  image = eclass->image;
  if (rank == 1) goto <D.26077>; else goto <D.26075>;
  <D.26077>:
  if (bounded == 0) goto <D.26078>; else goto <D.26075>;
  <D.26078>:
  {
    int ret;

    D.26079 = &image->szarray_cache_lock.mutex;
    ret = pthread_mutex_lock (D.26079);
    if (ret != 0) goto <D.26080>; else goto <D.26081>;
    <D.26080>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
    <D.26081>:
    D.26082 = ret != 0;
    D.26083 = (long int) D.26082;
    D.26084 = __builtin_expect (D.26083, 0);
    if (D.26084 != 0) goto <D.26085>; else goto <D.26086>;
    <D.26085>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "class.c", 6400, "ret == 0");
    <D.26086>:
  }
  D.26087 = image->szarray_cache;
  if (D.26087 == 0B) goto <D.26088>; else goto <D.26089>;
  <D.26088>:
  D.26090 = monoeg_g_hash_table_new (mono_aligned_addr_hash, 0B);
  image->szarray_cache = D.26090;
  <D.26089>:
  D.26087 = image->szarray_cache;
  class = monoeg_g_hash_table_lookup (D.26087, eclass);
  {
    int ret;

    D.26079 = &image->szarray_cache_lock.mutex;
    ret = pthread_mutex_unlock (D.26079);
    if (ret != 0) goto <D.26091>; else goto <D.26092>;
    <D.26091>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.26092>:
    D.26093 = ret != 0;
    D.26094 = (long int) D.26093;
    D.26095 = __builtin_expect (D.26094, 0);
    if (D.26095 != 0) goto <D.26096>; else goto <D.26097>;
    <D.26096>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "class.c", 6404, "ret == 0");
    <D.26097>:
  }
  if (class != 0B) goto <D.26098>; else goto <D.26099>;
  <D.26098>:
  D.26100 = class;
  return D.26100;
  <D.26099>:
  mono_loader_lock ();
  goto <D.26076>;
  <D.26075>:
  mono_loader_lock ();
  D.26101 = image->array_cache;
  if (D.26101 == 0B) goto <D.26102>; else goto <D.26103>;
  <D.26102>:
  D.26104 = monoeg_g_hash_table_new (mono_aligned_addr_hash, 0B);
  image->array_cache = D.26104;
  <D.26103>:
  D.26101 = image->array_cache;
  list = monoeg_g_hash_table_lookup (D.26101, eclass);
  rootlist = list;
  if (rootlist != 0B) goto <D.26105>; else goto <D.26106>;
  <D.26105>:
  goto <D.20373>;
  <D.20372>:
  class = list->data;
  D.26107 = class->rank;
  D.26108 = (unsigned int) D.26107;
  if (D.26108 == rank) goto <D.26109>; else goto <D.26110>;
  <D.26109>:
  D.26111 = class->byval_arg.type;
  D.26112 = (int) D.26111;
  if (rank > 1) goto <D.26114>; else goto <D.26117>;
  <D.26117>:
  if (bounded != 0) goto <D.26114>; else goto <D.26115>;
  <D.26114>:
  iftmp.205 = 20;
  goto <D.26116>;
  <D.26115>:
  iftmp.205 = 29;
  <D.26116>:
  if (D.26112 == iftmp.205) goto <D.26118>; else goto <D.26119>;
  <D.26118>:
  mono_loader_unlock ();
  D.26100 = class;
  return D.26100;
  <D.26119>:
  <D.26110>:
  list = list->next;
  <D.20373>:
  if (list != 0B) goto <D.20372>; else goto <D.20374>;
  <D.20374>:
  <D.26106>:
  <D.26076>:
  D.26122 = image->assembly;
  if (D.26122 != 0B) goto <D.26123>; else goto <D.26120>;
  <D.26123>:
  D.26122 = image->assembly;
  D.26124 = D.26122->dynamic;
  if (D.26124 != 0) goto <D.26125>; else goto <D.26120>;
  <D.26125>:
  D.26126 = image->assembly_name;
  if (D.26126 != 0B) goto <D.26127>; else goto <D.26120>;
  <D.26127>:
  D.26126 = image->assembly_name;
  D.26128 = strcmp (D.26126, "mscorlib");
  if (D.26128 == 0) goto <D.26129>; else goto <D.26120>;
  <D.26129>:
  parent = mono_class_from_name (image, "System", "Array");
  corlib_type = 1;
  goto <D.26121>;
  <D.26120>:
  parent = mono_defaults.array_class;
  D.26130 = BIT_FIELD_REF <*parent, 64, 256>;
  D.26131 = D.26130 & 9223372036854775808;
  if (D.26131 == 0) goto <D.26132>; else goto <D.26133>;
  <D.26132>:
  mono_class_init (parent);
  <D.26133>:
  <D.26121>:
  class = mono_image_alloc0 (image, 272);
  class->image = image;
  D.26134 = eclass->name_space;
  class->name_space = D.26134;
  D.26135 = eclass->name;
  D.26136 = __strlen_g (D.26135);
  nsize = (int) D.26136;
  nsize.206 = (unsigned int) nsize;
  D.26138 = nsize.206 + rank;
  D.26139 = D.26138 + 3;
  D.26140 = (long unsigned int) D.26139;
  name = monoeg_malloc (D.26140);
  D.26135 = eclass->name;
  D.26141 = (long unsigned int) nsize;
  memcpy (name, D.26135, D.26141);
  D.26142 = (sizetype) nsize;
  D.26143 = name + D.26142;
  *D.26143 = 91;
  if (rank > 1) goto <D.26144>; else goto <D.26145>;
  <D.26144>:
  D.26142 = (sizetype) nsize;
  D.26146 = D.26142 + 1;
  D.26147 = name + D.26146;
  D.26148 = rank + 4294967295;
  D.26149 = (long unsigned int) D.26148;
  memset (D.26147, 44, D.26149);
  <D.26145>:
  if (bounded != 0) goto <D.26150>; else goto <D.26151>;
  <D.26150>:
  nsize.206 = (unsigned int) nsize;
  D.26138 = nsize.206 + rank;
  D.26152 = (sizetype) D.26138;
  D.26153 = name + D.26152;
  *D.26153 = 42;
  <D.26151>:
  nsize.206 = (unsigned int) nsize;
  D.26138 = nsize.206 + rank;
  bounded.207 = (unsigned int) bounded;
  D.26155 = D.26138 + bounded.207;
  D.26156 = (sizetype) D.26155;
  D.26157 = name + D.26156;
  *D.26157 = 93;
  nsize.206 = (unsigned int) nsize;
  D.26138 = nsize.206 + rank;
  bounded.207 = (unsigned int) bounded;
  D.26155 = D.26138 + bounded.207;
  D.26158 = D.26155 + 1;
  D.26159 = (sizetype) D.26158;
  D.26160 = name + D.26159;
  *D.26160 = 0;
  D.26161 = mono_image_strdup (image, name);
  class->name = D.26161;
  monoeg_g_free (name);
  mono_profiler_class_event (class, 0);
  classes_size.208 = classes_size;
  D.26163 = classes_size.208 + 272;
  classes_size = D.26163;
  class->type_token = 0;
  class->flags = 8449;
  class->parent = parent;
  D.26164 = class->parent;
  D.26165 = mono_class_instance_size (D.26164);
  class->instance_size = D.26165;
  D.26169 = eclass->byval_arg.type;
  if (D.26169 == 22) goto <D.26166>; else goto <D.26170>;
  <D.26170>:
  D.26169 = eclass->byval_arg.type;
  if (D.26169 == 1) goto <D.26166>; else goto <D.26167>;
  <D.26166>:
  mono_class_set_failure (class, 7, 0B);
  goto <D.26168>;
  <D.26167>:
  D.26173 = BIT_FIELD_REF <*eclass, 64, 256>;
  D.26174 = D.26173 & 576460752303423488;
  if (D.26174 != 0) goto <D.26175>; else goto <D.26171>;
  <D.26175>:
  D.26176 = mono_class_enum_basetype (eclass);
  if (D.26176 == 0B) goto <D.26177>; else goto <D.26171>;
  <D.26177>:
  D.26180 = eclass->ref_info_handle;
  if (D.26180 == 0) goto <D.26178>; else goto <D.26181>;
  <D.26181>:
  D.26173 = BIT_FIELD_REF <*eclass, 64, 256>;
  D.26182 = D.26173 & 72057594037927936;
  if (D.26182 != 0) goto <D.26178>; else goto <D.26179>;
  <D.26178>:
  monoeg_g_log (0B, 16, "Only incomplete TypeBuilder objects are allowed to be an enum without base_type");
  D.26180 = eclass->ref_info_handle;
  if (D.26180 == 0) goto <D.26184>; else goto <D.26187>;
  <D.26187>:
  D.26173 = BIT_FIELD_REF <*eclass, 64, 256>;
  D.26182 = D.26173 & 72057594037927936;
  if (D.26182 != 0) goto <D.26184>; else goto <D.26185>;
  <D.26184>:
  iftmp.209 = 1;
  goto <D.26186>;
  <D.26185>:
  iftmp.209 = 0;
  <D.26186>:
  D.26188 = iftmp.209 != 0;
  D.26189 = (long int) D.26188;
  D.26190 = __builtin_expect (D.26189, 0);
  if (D.26190 != 0) goto <D.26191>; else goto <D.26192>;
  <D.26191>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "class.c", 6469, "eclass->ref_info_handle && !eclass->wastypebuilder");
  <D.26192>:
  <D.26179>:
  class->sizes.element_size = -1;
  goto <D.26172>;
  <D.26171>:
  D.26193 = mono_class_array_element_size (eclass);
  class->sizes.element_size = D.26193;
  <D.26172>:
  <D.26168>:
  mono_class_setup_supertypes (class);
  D.26194 = eclass->generic_class;
  if (D.26194 != 0B) goto <D.26195>; else goto <D.26196>;
  <D.26195>:
  mono_class_init (eclass);
  <D.26196>:
  D.26173 = BIT_FIELD_REF <*eclass, 64, 256>;
  D.26197 = D.26173 & 2305843009213693952;
  if (D.26197 == 0) goto <D.26198>; else goto <D.26199>;
  <D.26198>:
  mono_class_setup_fields (eclass);
  <D.26199>:
  D.26200 = eclass->exception_type;
  if (D.26200 != 0) goto <D.26201>; else goto <D.26202>;
  <D.26201>:
  mono_class_set_failure (class, 7, 0B);
  <D.26202>:
  D.26207 = &eclass->byval_arg;
  D.26208 = mono_type_is_reference (D.26207);
  if (D.26208 != 0) goto <D.26204>; else goto <D.26209>;
  <D.26209>:
  D.26173 = BIT_FIELD_REF <*eclass, 64, 256>;
  D.26210 = D.26173 & 68719476736;
  if (D.26210 != 0) goto <D.26204>; else goto <D.26205>;
  <D.26204>:
  iftmp.210 = 1;
  goto <D.26206>;
  <D.26205>:
  iftmp.210 = 0;
  <D.26206>:
  D.26211 = (unsigned char) iftmp.210;
  D.26212 = (<unnamed-unsigned:1>) D.26211;
  class->has_references = D.26212;
  D.26213 = (unsigned char) rank;
  class->rank = D.26213;
  D.26173 = BIT_FIELD_REF <*eclass, 64, 256>;
  D.26174 = D.26173 & 576460752303423488;
  if (D.26174 != 0) goto <D.26214>; else goto <D.26215>;
  <D.26214>:
  D.26216 = eclass->element_class;
  class->cast_class = D.26216;
  goto <D.26217>;
  <D.26215>:
  class->cast_class = eclass;
  <D.26217>:
  D.26218 = class->cast_class;
  D.26219 = D.26218->byval_arg.type;
  D.26220 = (int) D.26219;
  switch (D.26220) <default: <D.26225>, case 4: <D.20375>, case 7: <D.20377>, case 9: <D.20378>, case 11: <D.20379>, case 24: <D.20380>, case 25: <D.20381>>
  <D.20375>:
  D.26221 = mono_defaults.byte_class;
  class->cast_class = D.26221;
  goto <D.20376>;
  <D.20377>:
  D.26222 = mono_defaults.int16_class;
  class->cast_class = D.26222;
  goto <D.20376>;
  <D.20378>:
  D.26223 = mono_defaults.int32_class;
  class->cast_class = D.26223;
  goto <D.20376>;
  <D.20379>:
  <D.20380>:
  <D.20381>:
  D.26224 = mono_defaults.int64_class;
  class->cast_class = D.26224;
  goto <D.20376>;
  <D.26225>:
  <D.20376>:
  class->element_class = eclass;
  if (rank > 1) goto <D.26226>; else goto <D.26229>;
  <D.26229>:
  if (bounded != 0) goto <D.26226>; else goto <D.26227>;
  <D.26226>:
  {
    struct MonoArrayType * at;

    at = mono_image_alloc0 (image, 32);
    class->byval_arg.type = 20;
    class->byval_arg.data.array = at;
    at->eklass = eclass;
    D.26230 = (unsigned char) rank;
    at->rank = D.26230;
  }
  goto <D.26228>;
  <D.26227>:
  class->byval_arg.type = 29;
  class->byval_arg.data.klass = eclass;
  <D.26228>:
  class->this_arg = class->byval_arg;
  class->this_arg.byref = 1;
  if (corlib_type != 0) goto <D.26231>; else goto <D.26232>;
  <D.26231>:
  class->inited = 1;
  <D.26232>:
  D.26233 = eclass->generic_container;
  class->generic_container = D.26233;
  if (rank == 1) goto <D.26236>; else goto <D.26234>;
  <D.26236>:
  if (bounded == 0) goto <D.26237>; else goto <D.26234>;
  <D.26237>:
  {
    struct MonoClass * prev_class;

    {
      int ret;

      D.26079 = &image->szarray_cache_lock.mutex;
      ret = pthread_mutex_lock (D.26079);
      if (ret != 0) goto <D.26238>; else goto <D.26239>;
      <D.26238>:
      monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
      <D.26239>:
      D.26240 = ret != 0;
      D.26241 = (long int) D.26240;
      D.26242 = __builtin_expect (D.26241, 0);
      if (D.26242 != 0) goto <D.26243>; else goto <D.26244>;
      <D.26243>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "class.c", 6541, "ret == 0");
      <D.26244>:
    }
    D.26087 = image->szarray_cache;
    prev_class = monoeg_g_hash_table_lookup (D.26087, eclass);
    if (prev_class != 0B) goto <D.26245>; else goto <D.26246>;
    <D.26245>:
    class = prev_class;
    goto <D.26247>;
    <D.26246>:
    D.26087 = image->szarray_cache;
    monoeg_g_hash_table_insert_replace (D.26087, eclass, class, 0);
    <D.26247>:
    {
      int ret;

      D.26079 = &image->szarray_cache_lock.mutex;
      ret = pthread_mutex_unlock (D.26079);
      if (ret != 0) goto <D.26248>; else goto <D.26249>;
      <D.26248>:
      monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
      <D.26249>:
      D.26250 = ret != 0;
      D.26251 = (long int) D.26250;
      D.26252 = __builtin_expect (D.26251, 0);
      if (D.26252 != 0) goto <D.26253>; else goto <D.26254>;
      <D.26253>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "class.c", 6548, "ret == 0");
      <D.26254>:
    }
  }
  goto <D.26235>;
  <D.26234>:
  list = monoeg_g_slist_append (rootlist, class);
  D.26101 = image->array_cache;
  monoeg_g_hash_table_insert_replace (D.26101, eclass, list, 0);
  <D.26235>:
  mono_loader_unlock ();
  mono_profiler_class_loaded (class, 0);
  D.26100 = class;
  return D.26100;
}


mono_array_class_get (struct MonoClass * eclass, guint32 rank)
{
  struct MonoClass * D.26256;

  D.26256 = mono_bounded_array_class_get (eclass, rank, 0);
  return D.26256;
}


mono_class_instance_size (struct MonoClass * klass)
{
  long unsigned int D.26258;
  long unsigned int D.26259;
  int32_t D.26262;

  D.26258 = BIT_FIELD_REF <*klass, 64, 256>;
  D.26259 = D.26258 & 2305843009213693952;
  if (D.26259 == 0) goto <D.26260>; else goto <D.26261>;
  <D.26260>:
  mono_class_init (klass);
  <D.26261>:
  D.26262 = klass->instance_size;
  return D.26262;
}


mono_class_min_align (struct MonoClass * klass)
{
  long unsigned int D.26264;
  long unsigned int D.26265;
  int32_t D.26268;
  unsigned char D.26269;

  D.26264 = BIT_FIELD_REF <*klass, 64, 256>;
  D.26265 = D.26264 & 2305843009213693952;
  if (D.26265 == 0) goto <D.26266>; else goto <D.26267>;
  <D.26266>:
  mono_class_init (klass);
  <D.26267>:
  D.26269 = klass->min_align;
  D.26268 = (int32_t) D.26269;
  return D.26268;
}


mono_class_value_size (struct MonoClass * klass, guint32 * align)
{
  int D.26271;
  unsigned int D.26272;
  unsigned int D.26273;
  unsigned char D.26276;
  unsigned int D.26277;
  int32_t D.26278;
  gint32 size;

  D.26271 = mono_class_instance_size (klass);
  D.26272 = (unsigned int) D.26271;
  D.26273 = D.26272 + 4294967280;
  size = (gint32) D.26273;
  if (align != 0B) goto <D.26274>; else goto <D.26275>;
  <D.26274>:
  D.26276 = klass->min_align;
  D.26277 = (unsigned int) D.26276;
  *align = D.26277;
  <D.26275>:
  D.26278 = size;
  return D.26278;
}


mono_class_data_size (struct MonoClass * klass)
{
  long unsigned int D.26280;
  long unsigned int D.26281;
  long unsigned int D.26284;
  unsigned char D.26287;
  int32_t D.26290;

  D.26280 = BIT_FIELD_REF <*klass, 64, 256>;
  D.26281 = D.26280 & 9223372036854775808;
  if (D.26281 == 0) goto <D.26282>; else goto <D.26283>;
  <D.26282>:
  mono_class_init (klass);
  <D.26283>:
  D.26280 = BIT_FIELD_REF <*klass, 64, 256>;
  D.26284 = D.26280 & 67108864;
  if (D.26284 == 0) goto <D.26285>; else goto <D.26286>;
  <D.26285>:
  mono_class_setup_fields_locking (klass);
  <D.26286>:
  D.26287 = klass->rank;
  if (D.26287 != 0) goto <D.26288>; else goto <D.26289>;
  <D.26288>:
  D.26290 = 0;
  return D.26290;
  <D.26289>:
  D.26290 = klass->sizes.class_size;
  return D.26290;
}


mono_class_get_field (struct MonoClass * class, guint32 field_token)
{
  int field_token.211;
  unsigned int D.26293;
  _Bool D.26294;
  long int D.26295;
  long int D.26296;
  struct MonoClassField * D.26299;
  int D.26300;
  int idx;

  field_token.211 = (int) field_token;
  idx = field_token.211 & 16777215;
  D.26293 = field_token & 4278190080;
  D.26294 = D.26293 != 67108864;
  D.26295 = (long int) D.26294;
  D.26296 = __builtin_expect (D.26295, 0);
  if (D.26296 != 0) goto <D.26297>; else goto <D.26298>;
  <D.26297>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "class.c", 6707, "mono_metadata_token_code (field_token) == MONO_TOKEN_FIELD_DEF");
  <D.26298>:
  D.26300 = idx + -1;
  D.26299 = mono_class_get_field_idx (class, D.26300);
  return D.26299;
}


mono_class_get_field_idx (struct MonoClass * class, int idx)
{
  unsigned char D.26302;
  struct MonoClassField * D.26305;
  struct MonoImage * D.26306;
  long unsigned int D.26307;
  long unsigned int D.26308;
  struct MonoTableInfo * D.26311;
  unsigned int D.26312;
  struct MonoClassField * D.26313;
  long unsigned int D.26314;
  long unsigned int D.26315;
  struct MonoClassField * D.26316;
  const char * D.26317;
  unsigned int D.26320;
  unsigned int i.212;
  unsigned int D.26324;
  unsigned int idx.213;
  unsigned int D.26328;
  unsigned int D.26331;
  long unsigned int D.26332;
  long unsigned int D.26333;

  mono_class_setup_fields_locking (class);
  D.26302 = class->exception_type;
  if (D.26302 != 0) goto <D.26303>; else goto <D.26304>;
  <D.26303>:
  D.26305 = 0B;
  return D.26305;
  <D.26304>:
  goto <D.20414>;
  <D.20413>:
  D.26306 = class->image;
  D.26307 = BIT_FIELD_REF <*D.26306, 64, 192>;
  D.26308 = D.26307 & 67108864;
  if (D.26308 != 0) goto <D.26309>; else goto <D.26310>;
  <D.26309>:
  {
    const char * name;
    int i;

    D.26306 = class->image;
    D.26306 = class->image;
    D.26311 = &D.26306->tables[4];
    D.26312 = mono_metadata_decode_row_col (D.26311, idx, 1);
    name = mono_metadata_string_heap (D.26306, D.26312);
    i = 0;
    goto <D.20411>;
    <D.20410>:
    D.26313 = class->fields;
    D.26314 = (long unsigned int) i;
    D.26315 = D.26314 * 32;
    D.26316 = D.26313 + D.26315;
    D.26317 = mono_field_get_name (D.26316);
    if (D.26317 == name) goto <D.26318>; else goto <D.26319>;
    <D.26318>:
    D.26313 = class->fields;
    D.26314 = (long unsigned int) i;
    D.26315 = D.26314 * 32;
    D.26305 = D.26313 + D.26315;
    return D.26305;
    <D.26319>:
    i = i + 1;
    <D.20411>:
    D.26320 = class->field.count;
    i.212 = (unsigned int) i;
    if (D.26320 > i.212) goto <D.20410>; else goto <D.20412>;
    <D.20412>:
    monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "class.c", 6680);
  }
  <D.26310>:
  D.26320 = class->field.count;
  if (D.26320 != 0) goto <D.26322>; else goto <D.26323>;
  <D.26322>:
  D.26324 = class->field.first;
  idx.213 = (unsigned int) idx;
  if (D.26324 <= idx.213) goto <D.26326>; else goto <D.26327>;
  <D.26326>:
  D.26324 = class->field.first;
  D.26320 = class->field.count;
  D.26328 = D.26324 + D.26320;
  idx.213 = (unsigned int) idx;
  if (D.26328 > idx.213) goto <D.26329>; else goto <D.26330>;
  <D.26329>:
  D.26313 = class->fields;
  idx.213 = (unsigned int) idx;
  D.26324 = class->field.first;
  D.26331 = idx.213 - D.26324;
  D.26332 = (long unsigned int) D.26331;
  D.26333 = D.26332 * 32;
  D.26305 = D.26313 + D.26333;
  return D.26305;
  <D.26330>:
  <D.26327>:
  <D.26323>:
  class = class->parent;
  <D.20414>:
  if (class != 0B) goto <D.20413>; else goto <D.20415>;
  <D.20415>:
  D.26305 = 0B;
  return D.26305;
}


mono_class_get_field_from_name (struct MonoClass * klass, const char * name)
{
  struct MonoClassField * D.26335;

  D.26335 = mono_class_get_field_from_name_full (klass, name, 0B);
  return D.26335;
}


__attribute__((visibility ("hidden")))
mono_class_get_field_from_name_full (struct MonoClass * klass, const char * name, struct MonoType * type)
{
  unsigned char D.26337;
  struct MonoClassField * D.26340;
  struct MonoClassField * D.26341;
  long unsigned int D.26342;
  long unsigned int D.26343;
  const char * D.26344;
  int D.26345;
  struct MonoClassField * D.26350;
  int D.26351;
  unsigned int D.26354;
  unsigned int i.214;
  int i;

  mono_class_setup_fields_locking (klass);
  D.26337 = klass->exception_type;
  if (D.26337 != 0) goto <D.26338>; else goto <D.26339>;
  <D.26338>:
  D.26340 = 0B;
  return D.26340;
  <D.26339>:
  goto <D.20438>;
  <D.20437>:
  i = 0;
  goto <D.20435>;
  <D.20434>:
  {
    struct MonoClassField * field;

    D.26341 = klass->fields;
    D.26342 = (long unsigned int) i;
    D.26343 = D.26342 * 32;
    field = D.26341 + D.26343;
    D.26344 = mono_field_get_name (field);
    D.26345 = strcmp (name, D.26344);
    if (D.26345 != 0) goto <D.26346>; else goto <D.26347>;
    <D.26346>:
    // predicted unlikely by continue predictor.
    goto <D.20432>;
    <D.26347>:
    if (type != 0B) goto <D.26348>; else goto <D.26349>;
    <D.26348>:
    {
      struct MonoType * field_type;

      D.26350 = mono_metadata_get_corresponding_field_from_generic_type_definition (field);
      field_type = D.26350->type;
      D.26351 = mono_metadata_type_equal_full (type, field_type, 1);
      if (D.26351 == 0) goto <D.26352>; else goto <D.26353>;
      <D.26352>:
      // predicted unlikely by continue predictor.
      goto <D.20432>;
      <D.26353>:
    }
    <D.26349>:
    D.26340 = field;
    return D.26340;
  }
  <D.20432>:
  i = i + 1;
  <D.20435>:
  D.26354 = klass->field.count;
  i.214 = (unsigned int) i;
  if (D.26354 > i.214) goto <D.20434>; else goto <D.20436>;
  <D.20436>:
  klass = klass->parent;
  <D.20438>:
  if (klass != 0B) goto <D.20437>; else goto <D.20439>;
  <D.20439>:
  D.26340 = 0B;
  return D.26340;
}


mono_class_get_field_token (struct MonoClassField * field)
{
  struct MonoClassField * D.26357;
  uint32_t D.26360;
  long unsigned int D.26361;
  long unsigned int D.26362;
  struct MonoClassField * D.26363;
  unsigned int D.26366;
  unsigned int i.215;
  unsigned int D.26368;
  unsigned int D.26369;
  struct MonoImage * D.26370;
  long unsigned int D.26371;
  long unsigned int D.26372;
  unsigned int idx.216;
  unsigned int D.26376;
  int D.26377;
  unsigned int D.26378;
  struct MonoClass * klass;
  int i;

  klass = field->parent;
  mono_class_setup_fields_locking (klass);
  goto <D.20450>;
  <D.20449>:
  D.26357 = klass->fields;
  if (D.26357 == 0B) goto <D.26358>; else goto <D.26359>;
  <D.26358>:
  D.26360 = 0;
  return D.26360;
  <D.26359>:
  i = 0;
  goto <D.20447>;
  <D.20446>:
  D.26357 = klass->fields;
  D.26361 = (long unsigned int) i;
  D.26362 = D.26361 * 32;
  D.26363 = D.26357 + D.26362;
  if (D.26363 == field) goto <D.26364>; else goto <D.26365>;
  <D.26364>:
  {
    int idx;

    D.26366 = klass->field.first;
    i.215 = (unsigned int) i;
    D.26368 = D.26366 + i.215;
    D.26369 = D.26368 + 1;
    idx = (int) D.26369;
    D.26370 = klass->image;
    D.26371 = BIT_FIELD_REF <*D.26370, 64, 192>;
    D.26372 = D.26371 & 67108864;
    if (D.26372 != 0) goto <D.26373>; else goto <D.26374>;
    <D.26373>:
    D.26370 = klass->image;
    idx.216 = (unsigned int) idx;
    D.26376 = mono_metadata_translate_token_index (D.26370, 4, idx.216);
    idx = (int) D.26376;
    <D.26374>:
    D.26377 = idx | 67108864;
    D.26360 = (uint32_t) D.26377;
    return D.26360;
  }
  <D.26365>:
  i = i + 1;
  <D.20447>:
  D.26378 = klass->field.count;
  i.215 = (unsigned int) i;
  if (D.26378 > i.215) goto <D.20446>; else goto <D.20448>;
  <D.20448>:
  klass = klass->parent;
  <D.20450>:
  if (klass != 0B) goto <D.20449>; else goto <D.20451>;
  <D.20451>:
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "class.c", 6800);
  D.26360 = 0;
  return D.26360;
}


__attribute__((visibility ("hidden")))
mono_class_get_field_default_value (struct MonoClassField * field, MonoTypeEnum * def_type)
{
  struct MonoType * D.26380;
  short unsigned int D.26381;
  signed short D.26382;
  _Bool D.26383;
  long int D.26384;
  long int D.26385;
  struct MonoClassExt * D.26390;
  struct MonoFieldDefaultValue * D.26392;
  unsigned int D.26395;
  unsigned int D.26396;
  int D.26397;
  void * D.26398;
  long unsigned int D.26399;
  long unsigned int D.26400;
  struct MonoFieldDefaultValue * D.26401;
  const char * D.26402;
  struct MonoClass * D.26405;
  struct MonoImage * D.26406;
  unsigned int D.26407;
  const char * D.26410;
  int D.26411;
  int D.26412;
  _Bool D.26413;
  long int D.26414;
  long int D.26415;
  struct MonoTableInfo * D.26418;
  unsigned int D.26419;
  int D.26420;
  unsigned int D.26421;
  unsigned int D.26422;
  const char * D.26423;
  <unnamed type> D.26424;
  guint32 cindex;
  guint32 constant_cols[4];
  int field_index;
  struct MonoClass * klass;

  try
    {
      klass = field->parent;
      D.26380 = field->type;
      D.26381 = D.26380->attrs;
      D.26382 = (signed short) D.26381;
      D.26383 = D.26382 >= 0;
      D.26384 = (long int) D.26383;
      D.26385 = __builtin_expect (D.26384, 0);
      if (D.26385 != 0) goto <D.26386>; else goto <D.26387>;
      <D.26386>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "class.c", 6827, "field->type->attrs & FIELD_ATTRIBUTE_HAS_DEFAULT");
      <D.26387>:
      D.26390 = klass->ext;
      if (D.26390 == 0B) goto <D.26388>; else goto <D.26391>;
      <D.26391>:
      D.26390 = klass->ext;
      D.26392 = D.26390->field_def_values;
      if (D.26392 == 0B) goto <D.26388>; else goto <D.26389>;
      <D.26388>:
      mono_loader_lock ();
      mono_class_alloc_ext (klass);
      D.26390 = klass->ext;
      D.26392 = D.26390->field_def_values;
      if (D.26392 == 0B) goto <D.26393>; else goto <D.26394>;
      <D.26393>:
      D.26390 = klass->ext;
      D.26395 = klass->field.count;
      D.26396 = D.26395 * 16;
      D.26397 = (int) D.26396;
      D.26398 = mono_class_alloc0 (klass, D.26397);
      D.26390->field_def_values = D.26398;
      <D.26394>:
      mono_loader_unlock ();
      <D.26389>:
      field_index = mono_field_get_index (field);
      D.26390 = klass->ext;
      D.26392 = D.26390->field_def_values;
      D.26399 = (long unsigned int) field_index;
      D.26400 = D.26399 * 16;
      D.26401 = D.26392 + D.26400;
      D.26402 = D.26401->data;
      if (D.26402 == 0B) goto <D.26403>; else goto <D.26404>;
      <D.26403>:
      D.26405 = field->parent;
      D.26406 = D.26405->image;
      D.26407 = mono_class_get_field_token (field);
      cindex = mono_metadata_get_constant_index (D.26406, D.26407, 0);
      if (cindex == 0) goto <D.26408>; else goto <D.26409>;
      <D.26408>:
      D.26410 = 0B;
      return D.26410;
      <D.26409>:
      D.26380 = field->type;
      D.26381 = D.26380->attrs;
      D.26411 = (int) D.26381;
      D.26412 = D.26411 & 256;
      D.26413 = D.26412 != 0;
      D.26414 = (long int) D.26413;
      D.26415 = __builtin_expect (D.26414, 0);
      if (D.26415 != 0) goto <D.26416>; else goto <D.26417>;
      <D.26416>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "class.c", 6844, "!(field->type->attrs & FIELD_ATTRIBUTE_HAS_FIELD_RVA)");
      <D.26417>:
      D.26405 = field->parent;
      D.26406 = D.26405->image;
      D.26418 = &D.26406->tables[11];
      D.26419 = cindex + 4294967295;
      D.26420 = (int) D.26419;
      mono_metadata_decode_row (D.26418, D.26420, &constant_cols, 4);
      D.26390 = klass->ext;
      D.26392 = D.26390->field_def_values;
      D.26399 = (long unsigned int) field_index;
      D.26400 = D.26399 * 16;
      D.26401 = D.26392 + D.26400;
      D.26421 = constant_cols[0];
      D.26401->def_type = D.26421;
      D.26390 = klass->ext;
      D.26392 = D.26390->field_def_values;
      D.26399 = (long unsigned int) field_index;
      D.26400 = D.26399 * 16;
      D.26401 = D.26392 + D.26400;
      D.26405 = field->parent;
      D.26406 = D.26405->image;
      D.26422 = constant_cols[3];
      D.26423 = mono_metadata_blob_heap (D.26406, D.26422);
      D.26401->data = D.26423;
      <D.26404>:
      D.26390 = klass->ext;
      D.26392 = D.26390->field_def_values;
      D.26399 = (long unsigned int) field_index;
      D.26400 = D.26399 * 16;
      D.26401 = D.26392 + D.26400;
      D.26424 = D.26401->def_type;
      *def_type = D.26424;
      D.26390 = klass->ext;
      D.26392 = D.26390->field_def_values;
      D.26399 = (long unsigned int) field_index;
      D.26400 = D.26399 * 16;
      D.26401 = D.26392 + D.26400;
      D.26410 = D.26401->data;
      return D.26410;
    }
  finally
    {
      constant_cols = {CLOBBER};
    }
}


mono_field_get_index (struct MonoClassField * field)
{
  long int field.217;
  struct MonoClass * D.26428;
  struct MonoClassField * D.26429;
  long int D.26430;
  long int D.26431;
  long int D.26432;
  int iftmp.218;
  unsigned int D.26438;
  unsigned int index.219;
  _Bool D.26440;
  long int D.26441;
  long int D.26442;
  int D.26445;
  int index;

  field.217 = (long int) field;
  D.26428 = field->parent;
  D.26429 = D.26428->fields;
  D.26430 = (long int) D.26429;
  D.26431 = field.217 - D.26430;
  D.26432 = D.26431 /[ex] 32;
  index = (int) D.26432;
  if (index < 0) goto <D.26434>; else goto <D.26437>;
  <D.26437>:
  D.26428 = field->parent;
  D.26438 = D.26428->field.count;
  index.219 = (unsigned int) index;
  if (D.26438 <= index.219) goto <D.26434>; else goto <D.26435>;
  <D.26434>:
  iftmp.218 = 1;
  goto <D.26436>;
  <D.26435>:
  iftmp.218 = 0;
  <D.26436>:
  D.26440 = iftmp.218 != 0;
  D.26441 = (long int) D.26440;
  D.26442 = __builtin_expect (D.26441, 0);
  if (D.26442 != 0) goto <D.26443>; else goto <D.26444>;
  <D.26443>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "class.c", 6809, "index >= 0 && index < field->parent->field.count");
  <D.26444>:
  D.26445 = index;
  return D.26445;
}


__attribute__((visibility ("hidden")))
mono_class_get_property_default_value (struct MonoProperty * property, MonoTypeEnum * def_type)
{
  unsigned int D.26447;
  unsigned int D.26448;
  _Bool D.26449;
  long int D.26450;
  long int D.26451;
  struct MonoImage * D.26454;
  long unsigned int D.26455;
  long unsigned int D.26456;
  struct MonoClassExt * D.26459;
  struct MonoFieldDefaultValue * D.26460;
  long unsigned int D.26463;
  long unsigned int D.26464;
  struct MonoFieldDefaultValue * D.26465;
  const char * D.26466;
  <unnamed type> D.26469;
  const char * D.26470;
  unsigned int D.26471;
  struct MonoTableInfo * D.26474;
  unsigned int D.26475;
  int D.26476;
  unsigned int D.26477;
  unsigned int D.26478;
  guint32 cindex;
  guint32 constant_cols[4];
  struct MonoClass * klass;

  try
    {
      klass = property->parent;
      D.26447 = property->attrs;
      D.26448 = D.26447 & 4096;
      D.26449 = D.26448 == 0;
      D.26450 = (long int) D.26449;
      D.26451 = __builtin_expect (D.26450, 0);
      if (D.26451 != 0) goto <D.26452>; else goto <D.26453>;
      <D.26452>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "class.c", 6877, "property->attrs & PROPERTY_ATTRIBUTE_HAS_DEFAULT");
      <D.26453>:
      D.26454 = klass->image;
      D.26455 = BIT_FIELD_REF <*D.26454, 64, 192>;
      D.26456 = D.26455 & 268435456;
      if (D.26456 != 0) goto <D.26457>; else goto <D.26458>;
      <D.26457>:
      {
        int prop_index;

        prop_index = mono_property_get_index (property);
        D.26459 = klass->ext;
        D.26460 = D.26459->prop_def_values;
        if (D.26460 != 0B) goto <D.26461>; else goto <D.26462>;
        <D.26461>:
        D.26459 = klass->ext;
        D.26460 = D.26459->prop_def_values;
        D.26463 = (long unsigned int) prop_index;
        D.26464 = D.26463 * 16;
        D.26465 = D.26460 + D.26464;
        D.26466 = D.26465->data;
        if (D.26466 != 0B) goto <D.26467>; else goto <D.26468>;
        <D.26467>:
        D.26459 = klass->ext;
        D.26460 = D.26459->prop_def_values;
        D.26463 = (long unsigned int) prop_index;
        D.26464 = D.26463 * 16;
        D.26465 = D.26460 + D.26464;
        D.26469 = D.26465->def_type;
        *def_type = D.26469;
        D.26459 = klass->ext;
        D.26460 = D.26459->prop_def_values;
        D.26463 = (long unsigned int) prop_index;
        D.26464 = D.26463 * 16;
        D.26465 = D.26460 + D.26464;
        D.26470 = D.26465->data;
        return D.26470;
        <D.26468>:
        <D.26462>:
        D.26470 = 0B;
        return D.26470;
      }
      <D.26458>:
      D.26454 = klass->image;
      D.26471 = mono_class_get_property_token (property);
      cindex = mono_metadata_get_constant_index (D.26454, D.26471, 0);
      if (cindex == 0) goto <D.26472>; else goto <D.26473>;
      <D.26472>:
      D.26470 = 0B;
      return D.26470;
      <D.26473>:
      D.26454 = klass->image;
      D.26474 = &D.26454->tables[11];
      D.26475 = cindex + 4294967295;
      D.26476 = (int) D.26475;
      mono_metadata_decode_row (D.26474, D.26476, &constant_cols, 4);
      D.26477 = constant_cols[0];
      *def_type = D.26477;
      D.26454 = klass->image;
      D.26478 = constant_cols[3];
      D.26470 = mono_metadata_blob_heap (D.26454, D.26478);
      return D.26470;
    }
  finally
    {
      constant_cols = {CLOBBER};
    }
}


mono_property_get_index (struct MonoProperty * prop)
{
  long int prop.220;
  struct MonoClass * D.26482;
  struct MonoClassExt * D.26483;
  struct MonoProperty * D.26484;
  long int D.26485;
  long int D.26486;
  long int D.26487;
  int iftmp.221;
  unsigned int D.26493;
  unsigned int index.222;
  _Bool D.26495;
  long int D.26496;
  long int D.26497;
  int D.26500;
  int index;

  prop.220 = (long int) prop;
  D.26482 = prop->parent;
  D.26483 = D.26482->ext;
  D.26484 = D.26483->properties;
  D.26485 = (long int) D.26484;
  D.26486 = prop.220 - D.26485;
  D.26487 = D.26486 /[ex] 40;
  index = (int) D.26487;
  if (index < 0) goto <D.26489>; else goto <D.26492>;
  <D.26492>:
  D.26482 = prop->parent;
  D.26483 = D.26482->ext;
  D.26493 = D.26483->property.count;
  index.222 = (unsigned int) index;
  if (D.26493 <= index.222) goto <D.26489>; else goto <D.26490>;
  <D.26489>:
  iftmp.221 = 1;
  goto <D.26491>;
  <D.26490>:
  iftmp.221 = 0;
  <D.26491>:
  D.26495 = iftmp.221 != 0;
  D.26496 = (long int) D.26495;
  D.26497 = __builtin_expect (D.26496, 0);
  if (D.26497 != 0) goto <D.26498>; else goto <D.26499>;
  <D.26498>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "class.c", 6860, "index >= 0 && index < prop->parent->ext->property.count");
  <D.26499>:
  D.26500 = index;
  return D.26500;
}


mono_class_get_event_token (struct MonoEvent * event)
{
  struct MonoClassExt * D.26502;
  struct MonoEvent * D.26505;
  long unsigned int D.26506;
  long unsigned int D.26507;
  struct MonoEvent * D.26508;
  uint32_t D.26511;
  unsigned int D.26512;
  unsigned int i.223;
  unsigned int D.26514;
  unsigned int D.26515;
  unsigned int D.26516;
  struct MonoClass * klass;
  int i;

  klass = event->parent;
  goto <D.20485>;
  <D.20484>:
  D.26502 = klass->ext;
  if (D.26502 != 0B) goto <D.26503>; else goto <D.26504>;
  <D.26503>:
  i = 0;
  goto <D.20482>;
  <D.20481>:
  D.26502 = klass->ext;
  D.26505 = D.26502->events;
  D.26506 = (long unsigned int) i;
  D.26507 = D.26506 * 56;
  D.26508 = D.26505 + D.26507;
  if (D.26508 == event) goto <D.26509>; else goto <D.26510>;
  <D.26509>:
  D.26502 = klass->ext;
  D.26512 = D.26502->event.first;
  i.223 = (unsigned int) i;
  D.26514 = D.26512 + i.223;
  D.26515 = D.26514 + 1;
  D.26511 = D.26515 | 335544320;
  return D.26511;
  <D.26510>:
  i = i + 1;
  <D.20482>:
  D.26502 = klass->ext;
  D.26516 = D.26502->event.count;
  i.223 = (unsigned int) i;
  if (D.26516 > i.223) goto <D.20481>; else goto <D.20483>;
  <D.20483>:
  <D.26504>:
  klass = klass->parent;
  <D.20485>:
  if (klass != 0B) goto <D.20484>; else goto <D.20486>;
  <D.20486>:
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "class.c", 6917);
  D.26511 = 0;
  return D.26511;
}


mono_class_get_property_from_name (struct MonoClass * klass, const char * name)
{
  const char * D.26518;
  int D.26519;
  struct MonoProperty * D.26522;

  goto <D.20497>;
  <D.20496>:
  {
    struct MonoProperty * p;
    void * iter;

    try
      {
        iter = 0B;
        goto <D.20494>;
        <D.20493>:
        D.26518 = p->name;
        D.26519 = strcmp (name, D.26518);
        if (D.26519 == 0) goto <D.26520>; else goto <D.26521>;
        <D.26520>:
        D.26522 = p;
        return D.26522;
        <D.26521>:
        <D.20494>:
        p = mono_class_get_properties (klass, &iter);
        if (p != 0B) goto <D.20493>; else goto <D.20495>;
        <D.20495>:
        klass = klass->parent;
      }
    finally
      {
        iter = {CLOBBER};
      }
  }
  <D.20497>:
  if (klass != 0B) goto <D.20496>; else goto <D.20498>;
  <D.20498>:
  D.26522 = 0B;
  return D.26522;
}


mono_class_get_property_token (struct MonoProperty * prop)
{
  struct MonoClassExt * D.26526;
  struct MonoProperty * D.26527;
  long unsigned int D.26528;
  long unsigned int D.26529;
  struct MonoProperty * D.26530;
  uint32_t D.26533;
  unsigned int D.26534;
  unsigned int i.224;
  unsigned int D.26536;
  unsigned int D.26537;
  struct MonoClass * klass;

  klass = prop->parent;
  goto <D.20510>;
  <D.20509>:
  {
    struct MonoProperty * p;
    int i;
    void * iter;

    try
      {
        i = 0;
        iter = 0B;
        goto <D.20507>;
        <D.20506>:
        D.26526 = klass->ext;
        D.26527 = D.26526->properties;
        D.26528 = (long unsigned int) i;
        D.26529 = D.26528 * 40;
        D.26530 = D.26527 + D.26529;
        if (D.26530 == prop) goto <D.26531>; else goto <D.26532>;
        <D.26531>:
        D.26526 = klass->ext;
        D.26534 = D.26526->property.first;
        i.224 = (unsigned int) i;
        D.26536 = D.26534 + i.224;
        D.26537 = D.26536 + 1;
        D.26533 = D.26537 | 385875968;
        return D.26533;
        <D.26532>:
        i = i + 1;
        <D.20507>:
        p = mono_class_get_properties (klass, &iter);
        if (p != 0B) goto <D.20506>; else goto <D.20508>;
        <D.20508>:
        klass = klass->parent;
      }
    finally
      {
        iter = {CLOBBER};
      }
  }
  <D.20510>:
  if (klass != 0B) goto <D.20509>; else goto <D.20511>;
  <D.20511>:
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "class.c", 6953);
  D.26533 = 0;
  return D.26533;
}


mono_class_name_from_token (struct MonoImage * image, guint32 type_token)
{
  long unsigned int D.26541;
  long unsigned int D.26542;
  char * D.26545;
  unsigned int D.26546;
  <unnamed-unsigned:24> D.26547;
  unsigned int D.26548;
  unsigned int D.26551;
  int D.26552;
  unsigned int D.26553;
  unsigned int D.26554;
  long unsigned int D.26555;
  <unnamed-unsigned:24> D.26558;
  unsigned int D.26559;
  unsigned int D.26562;
  int D.26563;
  const char * D.26566;
  int D.26567;
  unsigned int D.26568;
  unsigned int D.26569;
  long unsigned int D.26570;
  const char * name;
  const char * nspace;

  D.26541 = BIT_FIELD_REF <*image, 64, 192>;
  D.26542 = D.26541 & 268435456;
  if (D.26542 != 0) goto <D.26543>; else goto <D.26544>;
  <D.26543>:
  D.26545 = monoeg_g_strdup_printf ("DynamicType 0x%08x", type_token);
  return D.26545;
  <D.26544>:
  D.26546 = type_token & 4278190080;
  switch (D.26546) <default: <D.20529>, case 16777216: <D.20522>, case 33554432: <D.20518>, case 452984832: <D.20528>>
  <D.20518>:
  {
    guint32 cols[6];
    struct MonoTableInfo * tt;
    guint tidx;

    try
      {
        tt = &image->tables[2];
        tidx = type_token & 16777215;
        D.26547 = tt->rows;
        D.26548 = (unsigned int) D.26547;
        if (D.26548 < tidx) goto <D.26549>; else goto <D.26550>;
        <D.26549>:
        D.26545 = monoeg_g_strdup_printf ("Invalid type token 0x%08x", type_token);
        return D.26545;
        <D.26550>:
        D.26551 = tidx + 4294967295;
        D.26552 = (int) D.26551;
        mono_metadata_decode_row (tt, D.26552, &cols, 6);
        D.26553 = cols[1];
        name = mono_metadata_string_heap (image, D.26553);
        D.26554 = cols[2];
        nspace = mono_metadata_string_heap (image, D.26554);
        D.26555 = __strlen_g (nspace);
        if (D.26555 == 0) goto <D.26556>; else goto <D.26557>;
        <D.26556>:
        D.26545 = monoeg_g_strdup_printf ("%s", name);
        return D.26545;
        <D.26557>:
        D.26545 = monoeg_g_strdup_printf ("%s.%s", nspace, name);
        return D.26545;
      }
    finally
      {
        cols = {CLOBBER};
      }
  }
  <D.20522>:
  {
    struct MonoError error;
    guint32 cols[3];
    struct MonoTableInfo * t;
    guint tidx;

    try
      {
        t = &image->tables[1];
        tidx = type_token & 16777215;
        D.26558 = t->rows;
        D.26559 = (unsigned int) D.26558;
        if (D.26559 < tidx) goto <D.26560>; else goto <D.26561>;
        <D.26560>:
        D.26545 = monoeg_g_strdup_printf ("Invalid type token 0x%08x", type_token);
        return D.26545;
        <D.26561>:
        D.26562 = tidx + 4294967295;
        D.26563 = mono_verifier_verify_typeref_row (image, D.26562, &error);
        if (D.26563 == 0) goto <D.26564>; else goto <D.26565>;
        <D.26564>:
        {
          char * msg;

          D.26566 = mono_error_get_message (&error);
          msg = monoeg_g_strdup_printf ("Invalid type token 0x%08x due to \'%s\'", type_token, D.26566);
          mono_error_cleanup (&error);
          D.26545 = msg;
          return D.26545;
        }
        <D.26565>:
        D.26562 = tidx + 4294967295;
        D.26567 = (int) D.26562;
        mono_metadata_decode_row (t, D.26567, &cols, 3);
        D.26568 = cols[1];
        name = mono_metadata_string_heap (image, D.26568);
        D.26569 = cols[2];
        nspace = mono_metadata_string_heap (image, D.26569);
        D.26570 = __strlen_g (nspace);
        if (D.26570 == 0) goto <D.26571>; else goto <D.26572>;
        <D.26571>:
        D.26545 = monoeg_g_strdup_printf ("%s", name);
        return D.26545;
        <D.26572>:
        D.26545 = monoeg_g_strdup_printf ("%s.%s", nspace, name);
        return D.26545;
      }
    finally
      {
        error = {CLOBBER};
        cols = {CLOBBER};
      }
  }
  <D.20528>:
  D.26545 = monoeg_g_strdup_printf ("Typespec 0x%08x", type_token);
  return D.26545;
  <D.20529>:
  D.26545 = monoeg_g_strdup_printf ("Invalid type token 0x%08x", type_token);
  return D.26545;
}


mono_class_get_full (struct MonoImage * image, guint32 type_token, struct MonoGenericContext * context)
{
  long unsigned int D.26576;
  long unsigned int D.26577;
  unsigned int D.26580;
  unsigned int table.225;
  unsigned int D.26582;
  gchar * D.26587;
  struct MonoClass * D.26588;
  unsigned int D.26589;
  int D.26590;
  int D.26593;
  struct MonoError error;
  struct MonoClass * class;

  try
    {
      class = 0B;
      D.26576 = BIT_FIELD_REF <*image, 64, 192>;
      D.26577 = D.26576 & 268435456;
      if (D.26577 != 0) goto <D.26578>; else goto <D.26579>;
      <D.26578>:
      {
        int table;

        D.26580 = type_token >> 24;
        table = (int) D.26580;
        table.225 = (unsigned int) table;
        D.26582 = table.225 + 4294967295;
        if (D.26582 > 1) goto <D.26583>; else goto <D.26584>;
        <D.26583>:
        if (table != 27) goto <D.26585>; else goto <D.26586>;
        <D.26585>:
        D.26587 = monoeg_strdup ("Bad type token.");
        mono_loader_set_error_bad_image (D.26587);
        D.26588 = 0B;
        return D.26588;
        <D.26586>:
        <D.26584>:
        D.26588 = mono_lookup_dynamic_token (image, type_token, context);
        return D.26588;
      }
      <D.26579>:
      D.26589 = type_token & 4278190080;
      switch (D.26589) <default: <D.20562>, case 16777216: <D.20560>, case 33554432: <D.20558>, case 452984832: <D.20561>>
      <D.20558>:
      class = mono_class_create_from_typedef (image, type_token, &error);
      D.26590 = mono_error_ok (&error);
      if (D.26590 == 0) goto <D.26591>; else goto <D.26592>;
      <D.26591>:
      mono_loader_set_error_from_mono_error (&error);
      mono_error_cleanup (&error);
      D.26588 = 0B;
      return D.26588;
      <D.26592>:
      goto <D.20559>;
      <D.20560>:
      class = mono_class_from_typeref (image, type_token);
      goto <D.20559>;
      <D.20561>:
      class = mono_class_create_from_typespec (image, type_token, context, &error);
      D.26593 = mono_error_ok (&error);
      if (D.26593 == 0) goto <D.26594>; else goto <D.26595>;
      <D.26594>:
      mono_error_cleanup (&error);
      <D.26595>:
      goto <D.20559>;
      <D.20562>:
      D.26589 = type_token & 4278190080;
      monoeg_g_log (0B, 16, "unknown token type %x", D.26589);
      monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "class.c", 7118);
      <D.20559>:
      if (class == 0B) goto <D.26596>; else goto <D.26597>;
      <D.26596>:
      {
        char * name;
        char * assembly;

        name = mono_class_name_from_token (image, type_token);
        assembly = mono_assembly_name_from_token (image, type_token);
        mono_loader_set_error_type_load (name, assembly);
        monoeg_g_free (name);
        monoeg_g_free (assembly);
      }
      <D.26597>:
      D.26588 = class;
      return D.26588;
    }
  finally
    {
      error = {CLOBBER};
    }
}


mono_class_create_from_typespec (struct MonoImage * image, guint32 type_spec, struct MonoGenericContext * context, struct MonoError * error)
{
  int D.26600;
  struct MonoClass * D.26603;
  int inflated.226;
  struct MonoClass * ret;
  gboolean inflated;
  struct MonoType * t;

  try
    {
      inflated = 0;
      t = mono_type_retrieve_from_typespec (image, type_spec, context, &inflated, error);
      D.26600 = mono_error_ok (error);
      if (D.26600 == 0) goto <D.26601>; else goto <D.26602>;
      <D.26601>:
      D.26603 = 0B;
      return D.26603;
      <D.26602>:
      ret = mono_class_from_mono_type (t);
      inflated.226 = inflated;
      if (inflated.226 != 0) goto <D.26605>; else goto <D.26606>;
      <D.26605>:
      mono_metadata_free_type (t);
      <D.26606>:
      D.26603 = ret;
      return D.26603;
    }
  finally
    {
      inflated = {CLOBBER};
    }
}


mono_type_retrieve_from_typespec (struct MonoImage * image, guint32 type_spec, struct MonoGenericContext * context, gboolean * did_inflate, struct MonoError * error)
{
  struct MonoType * D.26611;
  struct MonoGenericInst * D.26616;
  struct MonoGenericInst * D.26618;
  int D.26619;
  struct MonoType * t;

  t = mono_type_create_from_typespec (image, type_spec);
  mono_error_init (error);
  *did_inflate = 0;
  if (t == 0B) goto <D.26609>; else goto <D.26610>;
  <D.26609>:
  {
    char * name;
    char * assembly;

    name = mono_class_name_from_token (image, type_spec);
    assembly = mono_assembly_name_from_token (image, type_spec);
    mono_error_set_type_load_name (error, name, assembly, "Could not resolve typespec token %08x", type_spec);
    D.26611 = 0B;
    return D.26611;
  }
  <D.26610>:
  if (context != 0B) goto <D.26614>; else goto <D.26615>;
  <D.26614>:
  D.26616 = context->class_inst;
  if (D.26616 != 0B) goto <D.26612>; else goto <D.26617>;
  <D.26617>:
  D.26618 = context->method_inst;
  if (D.26618 != 0B) goto <D.26612>; else goto <D.26613>;
  <D.26612>:
  {
    struct MonoType * inflated;

    inflated = inflate_generic_type (0B, t, context, error);
    D.26619 = mono_error_ok (error);
    if (D.26619 == 0) goto <D.26620>; else goto <D.26621>;
    <D.26620>:
    D.26611 = 0B;
    return D.26611;
    <D.26621>:
    if (inflated != 0B) goto <D.26622>; else goto <D.26623>;
    <D.26622>:
    t = inflated;
    *did_inflate = 1;
    <D.26623>:
  }
  <D.26613>:
  <D.26615>:
  D.26611 = t;
  return D.26611;
}


mono_assembly_name_from_token (struct MonoImage * image, guint32 type_token)
{
  long unsigned int D.26625;
  long unsigned int D.26626;
  char * D.26629;
  char * D.26630;
  unsigned int D.26631;
  struct MonoAssembly * D.26632;
  struct MonoAssemblyName * D.26635;
  const char * D.26636;
  const char * iftmp.227;
  <unnamed-unsigned:24> D.26643;
  unsigned int D.26644;
  unsigned int D.26647;
  int D.26648;
  const char * D.26651;
  int D.26652;
  unsigned int D.26653;
  unsigned int D.26654;

  D.26625 = BIT_FIELD_REF <*image, 64, 192>;
  D.26626 = D.26625 & 268435456;
  if (D.26626 != 0) goto <D.26627>; else goto <D.26628>;
  <D.26627>:
  D.26630 = image->name;
  D.26629 = monoeg_g_strdup_printf ("DynamicAssembly %s", D.26630);
  return D.26629;
  <D.26628>:
  D.26631 = type_token & 4278190080;
  switch (D.26631) <default: <D.20549>, case 16777216: <D.20535>, case 33554432: <D.20534>, case 452984832: <D.20548>>
  <D.20534>:
  D.26632 = image->assembly;
  if (D.26632 != 0B) goto <D.26633>; else goto <D.26634>;
  <D.26633>:
  D.26632 = image->assembly;
  D.26635 = &D.26632->aname;
  D.26629 = mono_stringify_assembly_name (D.26635);
  return D.26629;
  <D.26634>:
  D.26636 = image->assembly_name;
  if (D.26636 != 0B) goto <D.26637>; else goto <D.26638>;
  <D.26637>:
  D.26636 = image->assembly_name;
  D.26629 = monoeg_strdup (D.26636);
  return D.26629;
  <D.26638>:
  D.26630 = image->name;
  if (D.26630 != 0B) goto <D.26640>; else goto <D.26641>;
  <D.26640>:
  iftmp.227 = image->name;
  goto <D.26642>;
  <D.26641>:
  iftmp.227 = "[Could not resolve assembly name";
  <D.26642>:
  D.26629 = monoeg_g_strdup_printf ("%s", iftmp.227);
  return D.26629;
  <D.20535>:
  {
    struct MonoError error;
    struct MonoAssemblyName aname;
    guint32 cols[3];
    struct MonoTableInfo * t;
    guint32 idx;

    try
      {
        t = &image->tables[1];
        idx = type_token & 16777215;
        D.26643 = t->rows;
        D.26644 = (unsigned int) D.26643;
        if (D.26644 < idx) goto <D.26645>; else goto <D.26646>;
        <D.26645>:
        D.26629 = monoeg_g_strdup_printf ("Invalid type token 0x%08x", type_token);
        return D.26629;
        <D.26646>:
        D.26647 = idx + 4294967295;
        D.26648 = mono_verifier_verify_typeref_row (image, D.26647, &error);
        if (D.26648 == 0) goto <D.26649>; else goto <D.26650>;
        <D.26649>:
        {
          char * msg;

          D.26651 = mono_error_get_message (&error);
          msg = monoeg_g_strdup_printf ("Invalid type token 0x%08x due to \'%s\'", type_token, D.26651);
          mono_error_cleanup (&error);
          D.26629 = msg;
          return D.26629;
        }
        <D.26650>:
        D.26647 = idx + 4294967295;
        D.26652 = (int) D.26647;
        mono_metadata_decode_row (t, D.26652, &cols, 3);
        D.26653 = cols[0];
        idx = D.26653 >> 2;
        D.26653 = cols[0];
        D.26654 = D.26653 & 3;
        switch (D.26654) <default: <D.20546>, case 0: <D.20542>, case 1: <D.20543>, case 2: <D.20545>, case 3: <D.20544>>
        <D.20542>:
        D.26629 = monoeg_strdup ("");
        return D.26629;
        <D.20543>:
        D.26629 = monoeg_strdup ("");
        return D.26629;
        <D.20544>:
        D.26629 = monoeg_strdup ("");
        return D.26629;
        <D.20545>:
        D.26647 = idx + 4294967295;
        D.26652 = (int) D.26647;
        mono_assembly_get_assemblyref (image, D.26652, &aname);
        D.26629 = mono_stringify_assembly_name (&aname);
        return D.26629;
        <D.20546>:
        monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "class.c", 7058);
        goto <D.20547>;
      }
    finally
      {
        error = {CLOBBER};
        aname = {CLOBBER};
        cols = {CLOBBER};
      }
  }
  <D.20548>:
  D.26629 = monoeg_strdup ("");
  return D.26629;
  <D.20549>:
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "class.c", 7066);
  <D.20547>:
  D.26629 = 0B;
  return D.26629;
}


__attribute__((visibility ("hidden")))
mono_type_get_full (struct MonoImage * image, guint32 type_token, struct MonoGenericContext * context)
{
  long unsigned int D.26658;
  long unsigned int D.26659;
  struct MonoType * D.26662;
  void * D.26663;
  unsigned int D.26664;
  struct MonoType * iftmp.228;
  int D.26671;
  const char * D.26674;
  int inflated.229;
  struct MonoClass * D.26678;
  unsigned char D.26679;
  unsigned char D.26680;
  struct MonoError error;
  struct MonoType * type;
  gboolean inflated;

  try
    {
      type = 0B;
      inflated = 0;
      D.26658 = BIT_FIELD_REF <*image, 64, 192>;
      D.26659 = D.26658 & 268435456;
      if (D.26659 != 0) goto <D.26660>; else goto <D.26661>;
      <D.26660>:
      D.26663 = mono_lookup_dynamic_token (image, type_token, context);
      D.26662 = mono_class_get_type (D.26663);
      return D.26662;
      <D.26661>:
      D.26664 = type_token & 4278190080;
      if (D.26664 != 452984832) goto <D.26665>; else goto <D.26666>;
      <D.26665>:
      {
        struct MonoClass * class;

        class = mono_class_get_full (image, type_token, context);
        if (class != 0B) goto <D.26668>; else goto <D.26669>;
        <D.26668>:
        iftmp.228 = mono_class_get_type (class);
        goto <D.26670>;
        <D.26669>:
        iftmp.228 = 0B;
        <D.26670>:
        D.26662 = iftmp.228;
        return D.26662;
      }
      <D.26666>:
      type = mono_type_retrieve_from_typespec (image, type_token, context, &inflated, &error);
      D.26671 = mono_error_ok (&error);
      if (D.26671 == 0) goto <D.26672>; else goto <D.26673>;
      <D.26672>:
      {
        char * name;
        char * assembly;

        name = mono_class_name_from_token (image, type_token);
        assembly = mono_assembly_name_from_token (image, type_token);
        D.26674 = mono_error_get_message (&error);
        monoeg_g_log (0B, 16, "Error loading type %s from %s due to %s", name, assembly, D.26674);
        mono_error_cleanup (&error);
        mono_loader_set_error_type_load (name, assembly);
        D.26662 = 0B;
        return D.26662;
      }
      <D.26673>:
      inflated.229 = inflated;
      if (inflated.229 != 0) goto <D.26676>; else goto <D.26677>;
      <D.26676>:
      {
        struct MonoType * tmp;

        tmp = type;
        D.26678 = mono_class_from_mono_type (type);
        type = mono_class_get_type (D.26678);
        D.26679 = type->type;
        D.26680 = tmp->type;
        if (D.26679 != D.26680) goto <D.26681>; else goto <D.26682>;
        <D.26681>:
        type = tmp;
        goto <D.26683>;
        <D.26682>:
        mono_metadata_free_type (tmp);
        <D.26683>:
      }
      <D.26677>:
      D.26662 = type;
      return D.26662;
    }
  finally
    {
      error = {CLOBBER};
      inflated = {CLOBBER};
    }
}


mono_class_get (struct MonoImage * image, guint32 type_token)
{
  struct MonoClass * D.26686;

  D.26686 = mono_class_get_full (image, type_token, 0B);
  return D.26686;
}


mono_image_init_name_cache (struct MonoImage * image)
{
  struct GHashTable * D.26688;
  struct GHashTable * D.26691;
  long unsigned int D.26692;
  long unsigned int D.26693;
  unsigned int D.26696;
  int D.26697;
  unsigned int D.26698;
  unsigned int D.26699;
  unsigned int D.26702;
  unsigned int D.26703;
  long unsigned int D.26704;
  const void * D.26705;
  void * D.26708;
  long unsigned int D.26709;
  void * D.26710;
  <unnamed-unsigned:24> D.26711;
  unsigned int D.26712;
  unsigned int D.26713;
  unsigned int D.26714;
  int D.26717;
  int D.26718;
  long unsigned int D.26719;
  void * D.26720;
  <unnamed-unsigned:24> D.26721;
  int D.26722;
  struct MonoTableInfo * t;
  guint32 cols[6];
  const char * name;
  const char * nspace;
  guint32 i;
  guint32 visib;
  guint32 nspace_index;
  struct GHashTable * name_cache2;
  struct GHashTable * nspace_table;

  try
    {
      t = &image->tables[2];
      mono_image_lock (image);
      D.26688 = image->name_cache;
      if (D.26688 != 0B) goto <D.26689>; else goto <D.26690>;
      <D.26689>:
      mono_image_unlock (image);
      return;
      <D.26690>:
      D.26691 = monoeg_g_hash_table_new (monoeg_g_str_hash, monoeg_g_str_equal);
      image->name_cache = D.26691;
      D.26692 = BIT_FIELD_REF <*image, 64, 192>;
      D.26693 = D.26692 & 268435456;
      if (D.26693 != 0) goto <D.26694>; else goto <D.26695>;
      <D.26694>:
      mono_image_unlock (image);
      return;
      <D.26695>:
      name_cache2 = monoeg_g_hash_table_new (0B, 0B);
      i = 1;
      goto <D.20595>;
      <D.20594>:
      D.26696 = i + 4294967295;
      D.26697 = (int) D.26696;
      mono_metadata_decode_row (t, D.26697, &cols, 6);
      D.26698 = cols[0];
      visib = D.26698 & 7;
      D.26699 = visib + 4294967294;
      if (D.26699 <= 5) goto <D.26700>; else goto <D.26701>;
      <D.26700>:
      // predicted unlikely by continue predictor.
      goto <D.20593>;
      <D.26701>:
      D.26702 = cols[1];
      name = mono_metadata_string_heap (image, D.26702);
      D.26703 = cols[2];
      nspace = mono_metadata_string_heap (image, D.26703);
      nspace_index = cols[2];
      D.26704 = (long unsigned int) nspace_index;
      D.26705 = (const void *) D.26704;
      nspace_table = monoeg_g_hash_table_lookup (name_cache2, D.26705);
      if (nspace_table == 0B) goto <D.26706>; else goto <D.26707>;
      <D.26706>:
      nspace_table = monoeg_g_hash_table_new (monoeg_g_str_hash, monoeg_g_str_equal);
      D.26688 = image->name_cache;
      monoeg_g_hash_table_insert_replace (D.26688, nspace, nspace_table, 0);
      D.26704 = (long unsigned int) nspace_index;
      D.26708 = (void *) D.26704;
      monoeg_g_hash_table_insert_replace (name_cache2, D.26708, nspace_table, 0);
      <D.26707>:
      D.26709 = (long unsigned int) i;
      D.26710 = (void *) D.26709;
      monoeg_g_hash_table_insert_replace (nspace_table, name, D.26710, 0);
      <D.20593>:
      i = i + 1;
      <D.20595>:
      D.26711 = t->rows;
      D.26712 = (unsigned int) D.26711;
      if (D.26712 >= i) goto <D.20594>; else goto <D.20596>;
      <D.20596>:
      {
        struct MonoTableInfo * t;
        guint32 cols[5];
        int i;

        try
          {
            t = &image->tables[39];
            i = 0;
            goto <D.20601>;
            <D.20600>:
            mono_metadata_decode_row (t, i, &cols, 5);
            D.26713 = cols[2];
            name = mono_metadata_string_heap (image, D.26713);
            D.26714 = cols[3];
            nspace = mono_metadata_string_heap (image, D.26714);
            nspace_index = cols[3];
            D.26704 = (long unsigned int) nspace_index;
            D.26705 = (const void *) D.26704;
            nspace_table = monoeg_g_hash_table_lookup (name_cache2, D.26705);
            if (nspace_table == 0B) goto <D.26715>; else goto <D.26716>;
            <D.26715>:
            nspace_table = monoeg_g_hash_table_new (monoeg_g_str_hash, monoeg_g_str_equal);
            D.26688 = image->name_cache;
            monoeg_g_hash_table_insert_replace (D.26688, nspace, nspace_table, 0);
            D.26704 = (long unsigned int) nspace_index;
            D.26708 = (void *) D.26704;
            monoeg_g_hash_table_insert_replace (name_cache2, D.26708, nspace_table, 0);
            <D.26716>:
            D.26717 = i + 1;
            D.26718 = D.26717 | 654311424;
            D.26719 = (long unsigned int) D.26718;
            D.26720 = (void *) D.26719;
            monoeg_g_hash_table_insert_replace (nspace_table, name, D.26720, 0);
            i = i + 1;
            <D.20601>:
            D.26721 = t->rows;
            D.26722 = (int) D.26721;
            if (D.26722 > i) goto <D.20600>; else goto <D.20602>;
            <D.20602>:
          }
        finally
          {
            cols = {CLOBBER};
          }
      }
      monoeg_g_hash_table_destroy (name_cache2);
      mono_image_unlock (image);
    }
  finally
    {
      cols = {CLOBBER};
    }
}


mono_image_add_to_name_cache (struct MonoImage * image, const char * nspace, const char * name, guint32 index)
{
  struct GHashTable * D.26726;
  void * D.26731;
  long int D.26732;
  char * D.26735;
  long unsigned int D.26736;
  void * D.26737;
  struct GHashTable * nspace_table;
  struct GHashTable * name_cache;
  guint32 old_index;

  mono_image_lock (image);
  D.26726 = image->name_cache;
  if (D.26726 == 0B) goto <D.26727>; else goto <D.26728>;
  <D.26727>:
  mono_image_init_name_cache (image);
  <D.26728>:
  name_cache = image->name_cache;
  nspace_table = monoeg_g_hash_table_lookup (name_cache, nspace);
  if (nspace_table == 0B) goto <D.26729>; else goto <D.26730>;
  <D.26729>:
  nspace_table = monoeg_g_hash_table_new (monoeg_g_str_hash, monoeg_g_str_equal);
  monoeg_g_hash_table_insert_replace (name_cache, nspace, nspace_table, 0);
  <D.26730>:
  D.26731 = monoeg_g_hash_table_lookup (nspace_table, name);
  D.26732 = (long int) D.26731;
  old_index = (guint32) D.26732;
  if (old_index != 0) goto <D.26733>; else goto <D.26734>;
  <D.26733>:
  D.26735 = image->name;
  monoeg_g_log (0B, 4, "overrwritting old token %x on image %s for type %s::%s", old_index, D.26735, nspace, name);
  <D.20612>:
  goto <D.20612>;
  <D.26734>:
  D.26736 = (long unsigned int) index;
  D.26737 = (void *) D.26736;
  monoeg_g_hash_table_insert_replace (nspace_table, name, D.26737, 0);
  mono_image_unlock (image);
}


mono_class_from_name_case (struct MonoImage * image, const char * name_space, const char * name)
{
  long unsigned int D.26738;
  long unsigned int D.26739;
  struct GHashTable * D.26742;
  void * D.26745;
  long int D.26750;
  struct MonoClass * D.26753;
  unsigned int D.26754;
  unsigned int D.26755;
  int D.26756;
  unsigned int D.26757;
  unsigned int D.26758;
  unsigned int D.26761;
  unsigned int D.26762;
  int D.26763;
  int D.26766;
  unsigned int D.26769;
  <unnamed-unsigned:24> D.26770;
  unsigned int D.26771;
  struct MonoTableInfo * t;
  guint32 cols[6];
  const char * n;
  const char * nspace;
  guint32 i;
  guint32 visib;

  try
    {
      t = &image->tables[2];
      D.26738 = BIT_FIELD_REF <*image, 64, 192>;
      D.26739 = D.26738 & 268435456;
      if (D.26739 != 0) goto <D.26740>; else goto <D.26741>;
      <D.26740>:
      {
        guint32 token;
        struct FindUserData user_data;

        try
          {
            token = 0;
            mono_image_lock (image);
            D.26742 = image->name_cache;
            if (D.26742 == 0B) goto <D.26743>; else goto <D.26744>;
            <D.26743>:
            mono_image_init_name_cache (image);
            <D.26744>:
            user_data.key = name_space;
            user_data.value = 0B;
            D.26742 = image->name_cache;
            monoeg_g_hash_table_foreach (D.26742, find_nocase, &user_data);
            D.26745 = user_data.value;
            if (D.26745 != 0B) goto <D.26746>; else goto <D.26747>;
            <D.26746>:
            {
              struct GHashTable * nspace_table;

              nspace_table = user_data.value;
              user_data.key = name;
              user_data.value = 0B;
              monoeg_g_hash_table_foreach (nspace_table, find_nocase, &user_data);
              D.26745 = user_data.value;
              if (D.26745 != 0B) goto <D.26748>; else goto <D.26749>;
              <D.26748>:
              D.26745 = user_data.value;
              D.26750 = (long int) D.26745;
              token = (guint32) D.26750;
              <D.26749>:
            }
            <D.26747>:
            mono_image_unlock (image);
            if (token != 0) goto <D.26751>; else goto <D.26752>;
            <D.26751>:
            D.26754 = token | 33554432;
            D.26753 = mono_class_get (image, D.26754);
            return D.26753;
            <D.26752>:
            D.26753 = 0B;
            return D.26753;
          }
        finally
          {
            user_data = {CLOBBER};
          }
      }
      <D.26741>:
      i = 1;
      goto <D.20640>;
      <D.20639>:
      D.26755 = i + 4294967295;
      D.26756 = (int) D.26755;
      mono_metadata_decode_row (t, D.26756, &cols, 6);
      D.26757 = cols[0];
      visib = D.26757 & 7;
      D.26758 = visib + 4294967294;
      if (D.26758 <= 5) goto <D.26759>; else goto <D.26760>;
      <D.26759>:
      // predicted unlikely by continue predictor.
      goto <D.20638>;
      <D.26760>:
      D.26761 = cols[1];
      n = mono_metadata_string_heap (image, D.26761);
      D.26762 = cols[2];
      nspace = mono_metadata_string_heap (image, D.26762);
      D.26763 = monoeg_ascii_strcasecmp (n, name);
      if (D.26763 == 0) goto <D.26764>; else goto <D.26765>;
      <D.26764>:
      D.26766 = monoeg_ascii_strcasecmp (nspace, name_space);
      if (D.26766 == 0) goto <D.26767>; else goto <D.26768>;
      <D.26767>:
      D.26769 = i | 33554432;
      D.26753 = mono_class_get (image, D.26769);
      return D.26753;
      <D.26768>:
      <D.26765>:
      <D.20638>:
      i = i + 1;
      <D.20640>:
      D.26770 = t->rows;
      D.26771 = (unsigned int) D.26770;
      if (D.26771 >= i) goto <D.20639>; else goto <D.20641>;
      <D.20641>:
      D.26753 = 0B;
      return D.26753;
    }
  finally
    {
      cols = {CLOBBER};
    }
}


find_nocase (void * key, void * value, void * user_data)
{
  void * D.26775;
  const void * D.26778;
  int D.26779;
  char * name;
  struct FindUserData * data;

  name = key;
  data = user_data;
  D.26775 = data->value;
  if (D.26775 == 0B) goto <D.26776>; else goto <D.26777>;
  <D.26776>:
  D.26778 = data->key;
  D.26779 = monoeg_ascii_strcasecmp (name, D.26778);
  if (D.26779 == 0) goto <D.26780>; else goto <D.26781>;
  <D.26780>:
  data->value = value;
  <D.26781>:
  <D.26777>:
}


mono_class_from_name (struct MonoImage * image, const char * name_space, const char * name)
{
  long int nested.230;
  long int name.231;
  long int D.26786;
  long unsigned int D.26787;
  struct MonoClass * D.26790;
  int D.26791;
  long unsigned int D.26792;
  sizetype D.26793;
  sizetype D.26794;
  gboolean (*<T1fe7>) (struct MonoImage *, const char *, const char *, struct MonoClass * *) get_class_from_name.232;
  long unsigned int D.26798;
  long unsigned int D.26799;
  struct MonoClass * class.233;
  struct MonoClass * class.234;
  struct MonoClass * iftmp.235;
  struct GHashTable * D.26814;
  void * D.26819;
  long int D.26820;
  long unsigned int D.26823;
  long unsigned int D.26824;
  struct MonoImage * * D.26827;
  long unsigned int D.26830;
  long unsigned int D.26831;
  struct MonoImage * * D.26832;
  struct MonoClass * class.236;
  unsigned int D.26836;
  unsigned int i.237;
  struct MonoClass * class.238;
  unsigned int D.26845;
  unsigned int D.26848;
  int D.26849;
  unsigned int D.26850;
  struct MonoAssembly * D.26853;
  unsigned int D.26854;
  struct MonoClass * class.239;
  unsigned int D.26862;
  int D.26863;
  struct MonoAssembly * * D.26864;
  long unsigned int D.26865;
  long unsigned int D.26866;
  struct MonoAssembly * * D.26867;
  struct MonoAssembly * D.26868;
  _Bool D.26869;
  long int D.26870;
  long int D.26871;
  struct MonoImage * D.26876;
  struct MonoClass * class.240;
  struct GHashTable * nspace_table;
  struct MonoImage * loaded_image;
  guint32 token;
  int i;
  struct MonoClass * class;
  char * nested;
  char buf[1024];

  try
    {
      token = 0;
      nested = __builtin_strchr (name, 47);
      if (nested != 0B) goto <D.26782>; else goto <D.26783>;
      <D.26782>:
      {
        int pos;
        int len;

        nested.230 = (long int) nested;
        name.231 = (long int) name;
        D.26786 = nested.230 - name.231;
        pos = (int) D.26786;
        D.26787 = __strlen_g (name);
        len = (int) D.26787;
        if (len > 1023) goto <D.26788>; else goto <D.26789>;
        <D.26788>:
        D.26790 = 0B;
        return D.26790;
        <D.26789>:
        D.26791 = len + 1;
        D.26792 = (long unsigned int) D.26791;
        memcpy (&buf, name, D.26792);
        buf[pos] = 0;
        D.26793 = (sizetype) pos;
        D.26794 = D.26793 + 1;
        nested = &buf + D.26794;
        name = &buf;
      }
      <D.26783>:
      get_class_from_name.232 = get_class_from_name;
      if (get_class_from_name.232 != 0B) goto <D.26796>; else goto <D.26797>;
      <D.26796>:
      D.26798 = BIT_FIELD_REF <*image, 64, 6592>;
      D.26799 = D.26798 & 18446742974197923840;
      if (D.26799 == 0) goto <D.26800>; else goto <D.26801>;
      <D.26800>:
      {
        gboolean res;

        get_class_from_name.232 = get_class_from_name;
        res = get_class_from_name.232 (image, name_space, name, &class);
        if (res != 0) goto <D.26802>; else goto <D.26803>;
        <D.26802>:
        class.233 = class;
        if (class.233 == 0B) goto <D.26805>; else goto <D.26806>;
        <D.26805>:
        class.234 = search_modules (image, name_space, name);
        class = class.234;
        <D.26806>:
        if (nested != 0B) goto <D.26808>; else goto <D.26809>;
        <D.26808>:
        class.233 = class;
        if (class.233 != 0B) goto <D.26811>; else goto <D.26812>;
        <D.26811>:
        class.233 = class;
        iftmp.235 = return_nested_in (class.233, nested);
        goto <D.26813>;
        <D.26812>:
        iftmp.235 = 0B;
        <D.26813>:
        D.26790 = iftmp.235;
        return D.26790;
        <D.26809>:
        D.26790 = class;
        return D.26790;
        <D.26803>:
      }
      <D.26801>:
      <D.26797>:
      mono_image_lock (image);
      D.26814 = image->name_cache;
      if (D.26814 == 0B) goto <D.26815>; else goto <D.26816>;
      <D.26815>:
      mono_image_init_name_cache (image);
      <D.26816>:
      D.26814 = image->name_cache;
      nspace_table = monoeg_g_hash_table_lookup (D.26814, name_space);
      if (nspace_table != 0B) goto <D.26817>; else goto <D.26818>;
      <D.26817>:
      D.26819 = monoeg_g_hash_table_lookup (nspace_table, name);
      D.26820 = (long int) D.26819;
      token = (guint32) D.26820;
      <D.26818>:
      mono_image_unlock (image);
      if (token == 0) goto <D.26821>; else goto <D.26822>;
      <D.26821>:
      D.26823 = BIT_FIELD_REF <*image, 64, 192>;
      D.26824 = D.26823 & 268435456;
      if (D.26824 != 0) goto <D.26825>; else goto <D.26826>;
      <D.26825>:
      D.26827 = image->modules;
      if (D.26827 != 0B) goto <D.26828>; else goto <D.26829>;
      <D.26828>:
      i = 0;
      goto <D.20683>;
      <D.20682>:
      {
        struct MonoImage * module;

        D.26827 = image->modules;
        D.26830 = (long unsigned int) i;
        D.26831 = D.26830 * 8;
        D.26832 = D.26827 + D.26831;
        module = *D.26832;
        class.236 = mono_class_from_name (module, name_space, name);
        class = class.236;
        class.233 = class;
        if (class.233 != 0B) goto <D.26834>; else goto <D.26835>;
        <D.26834>:
        D.26790 = class;
        return D.26790;
        <D.26835>:
      }
      i = i + 1;
      <D.20683>:
      D.26836 = image->module_count;
      i.237 = (unsigned int) i;
      if (D.26836 > i.237) goto <D.20682>; else goto <D.20684>;
      <D.20684>:
      <D.26829>:
      <D.26826>:
      <D.26822>:
      if (token == 0) goto <D.26838>; else goto <D.26839>;
      <D.26838>:
      class.238 = search_modules (image, name_space, name);
      class = class.238;
      class.233 = class;
      if (class.233 != 0B) goto <D.26841>; else goto <D.26842>;
      <D.26841>:
      D.26790 = class;
      return D.26790;
      <D.26842>:
      <D.26839>:
      if (token == 0) goto <D.26843>; else goto <D.26844>;
      <D.26843>:
      D.26790 = 0B;
      return D.26790;
      <D.26844>:
      D.26845 = token >> 24;
      if (D.26845 == 39) goto <D.26846>; else goto <D.26847>;
      <D.26846>:
      {
        struct MonoTableInfo * t;
        guint32 cols[5];
        guint32 idx;
        guint32 impl;

        try
          {
            t = &image->tables[39];
            idx = token & 16777215;
            D.26848 = idx + 4294967295;
            D.26849 = (int) D.26848;
            mono_metadata_decode_row (t, D.26849, &cols, 5);
            impl = cols[4];
            D.26850 = impl & 3;
            if (D.26850 == 0) goto <D.26851>; else goto <D.26852>;
            <D.26851>:
            D.26853 = image->assembly;
            D.26854 = impl >> 2;
            loaded_image = mono_assembly_load_module (D.26853, D.26854);
            if (loaded_image == 0B) goto <D.26855>; else goto <D.26856>;
            <D.26855>:
            D.26790 = 0B;
            return D.26790;
            <D.26856>:
            class.239 = mono_class_from_name (loaded_image, name_space, name);
            class = class.239;
            if (nested != 0B) goto <D.26858>; else goto <D.26859>;
            <D.26858>:
            class.233 = class;
            D.26790 = return_nested_in (class.233, nested);
            return D.26790;
            <D.26859>:
            D.26790 = class;
            return D.26790;
            <D.26852>:
            D.26850 = impl & 3;
            if (D.26850 == 1) goto <D.26860>; else goto <D.26861>;
            <D.26860>:
            {
              guint32 assembly_idx;

              assembly_idx = impl >> 2;
              D.26862 = assembly_idx + 4294967295;
              D.26863 = (int) D.26862;
              mono_assembly_load_reference (image, D.26863);
              D.26864 = image->references;
              D.26862 = assembly_idx + 4294967295;
              D.26865 = (long unsigned int) D.26862;
              D.26866 = D.26865 * 8;
              D.26867 = D.26864 + D.26866;
              D.26868 = *D.26867;
              D.26869 = D.26868 == 0B;
              D.26870 = (long int) D.26869;
              D.26871 = __builtin_expect (D.26870, 0);
              if (D.26871 != 0) goto <D.26872>; else goto <D.26873>;
              <D.26872>:
              monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "class.c", 7552, "image->references [assembly_idx - 1]");
              <D.26873>:
              D.26864 = image->references;
              D.26862 = assembly_idx + 4294967295;
              D.26865 = (long unsigned int) D.26862;
              D.26866 = D.26865 * 8;
              D.26867 = D.26864 + D.26866;
              D.26868 = *D.26867;
              if (D.26868 == -1B) goto <D.26874>; else goto <D.26875>;
              <D.26874>:
              D.26790 = 0B;
              return D.26790;
              <D.26875>:
              D.26864 = image->references;
              D.26862 = assembly_idx + 4294967295;
              D.26865 = (long unsigned int) D.26862;
              D.26866 = D.26865 * 8;
              D.26867 = D.26864 + D.26866;
              D.26868 = *D.26867;
              D.26876 = D.26868->image;
              D.26790 = mono_class_from_name (D.26876, name_space, name);
              return D.26790;
            }
            <D.26861>:
            monoeg_g_log (0B, 4, "not yet implemented");
            <D.20690>:
            goto <D.20690>;
          }
        finally
          {
            cols = {CLOBBER};
          }
      }
      <D.26847>:
      token = token | 33554432;
      class.240 = mono_class_get (image, token);
      class = class.240;
      if (nested != 0B) goto <D.26878>; else goto <D.26879>;
      <D.26878>:
      class.233 = class;
      D.26790 = return_nested_in (class.233, nested);
      return D.26790;
      <D.26879>:
      D.26790 = class;
      return D.26790;
    }
  finally
    {
      class = {CLOBBER};
      buf = {CLOBBER};
    }
}


search_modules (struct MonoImage * image, const char * name_space, const char * name)
{
  unsigned int D.26883;
  int D.26886;
  struct MonoClass * D.26891;
  <unnamed-unsigned:24> D.26892;
  int D.26893;
  struct MonoTableInfo * file_table;
  struct MonoImage * file_image;
  struct MonoClass * class;
  int i;

  file_table = &image->tables[38];
  i = 0;
  goto <D.20664>;
  <D.20663>:
  {
    guint32 cols[3];

    try
      {
        mono_metadata_decode_row (file_table, i, &cols, 3);
        D.26883 = cols[0];
        if (D.26883 == 1) goto <D.26884>; else goto <D.26885>;
        <D.26884>:
        // predicted unlikely by continue predictor.
        goto <D.20662>;
        <D.26885>:
        D.26886 = i + 1;
        file_image = mono_image_load_file_for_image (image, D.26886);
        if (file_image != 0B) goto <D.26887>; else goto <D.26888>;
        <D.26887>:
        class = mono_class_from_name (file_image, name_space, name);
        if (class != 0B) goto <D.26889>; else goto <D.26890>;
        <D.26889>:
        D.26891 = class;
        return D.26891;
        <D.26890>:
        <D.26888>:
      }
    finally
      {
        cols = {CLOBBER};
      }
  }
  <D.20662>:
  i = i + 1;
  <D.20664>:
  D.26892 = file_table->rows;
  D.26893 = (int) D.26892;
  if (D.26893 > i) goto <D.20663>; else goto <D.20665>;
  <D.20665>:
  D.26891 = 0B;
  return D.26891;
}


return_nested_in (struct MonoClass * class, char * nested)
{
  const char * D.26900;
  int D.26901;
  struct MonoClass * D.26906;
  struct MonoClass * found;
  char * s;
  void * iter;

  try
    {
      s = __builtin_strchr (nested, 47);
      iter = 0B;
      if (s != 0B) goto <D.26898>; else goto <D.26899>;
      <D.26898>:
      *s = 0;
      s = s + 1;
      <D.26899>:
      goto <D.20650>;
      <D.20649>:
      D.26900 = found->name;
      D.26901 = strcmp (D.26900, nested);
      if (D.26901 == 0) goto <D.26902>; else goto <D.26903>;
      <D.26902>:
      if (s != 0B) goto <D.26904>; else goto <D.26905>;
      <D.26904>:
      D.26906 = return_nested_in (found, s);
      return D.26906;
      <D.26905>:
      D.26906 = found;
      return D.26906;
      <D.26903>:
      <D.20650>:
      found = mono_class_get_nested_types (class, &iter);
      if (found != 0B) goto <D.20649>; else goto <D.20651>;
      <D.20651>:
      D.26906 = 0B;
      return D.26906;
    }
  finally
    {
      iter = {CLOBBER};
    }
}


mono_class_is_subclass_of (struct MonoClass * klass, struct MonoClass * klassc, gboolean check_interfaces)
{
  unsigned int D.26913;
  unsigned int D.26914;
  unsigned char D.26916;
  unsigned int D.26918;
  unsigned int D.26919;
  unsigned char D.26921;
  short unsigned int D.26924;
  short unsigned int D.26925;
  guint8 * D.26928;
  short unsigned int D.26929;
  sizetype D.26930;
  guint8 * D.26931;
  unsigned char D.26932;
  int D.26933;
  int D.26934;
  int D.26935;
  int D.26936;
  int D.26937;
  mono_bool D.26940;
  struct MonoClass * * D.26950;
  long unsigned int D.26951;
  long unsigned int D.26952;
  struct MonoClass * * D.26953;
  short unsigned int D.26956;
  int D.26957;
  int D.26964;
  struct MonoClass * D.26967;

  if (check_interfaces != 0) goto <D.26912>; else goto <D.26909>;
  <D.26912>:
  D.26913 = klassc->flags;
  D.26914 = D.26913 & 32;
  if (D.26914 != 0) goto <D.26910>; else goto <D.26915>;
  <D.26915>:
  D.26916 = klassc->byval_arg.type;
  if (D.26916 == 19) goto <D.26910>; else goto <D.26917>;
  <D.26917>:
  D.26916 = klassc->byval_arg.type;
  if (D.26916 == 30) goto <D.26910>; else goto <D.26909>;
  <D.26910>:
  D.26918 = klass->flags;
  D.26919 = D.26918 & 32;
  if (D.26919 == 0) goto <D.26920>; else goto <D.26909>;
  <D.26920>:
  D.26921 = klass->byval_arg.type;
  if (D.26921 != 19) goto <D.26922>; else goto <D.26909>;
  <D.26922>:
  D.26921 = klass->byval_arg.type;
  if (D.26921 != 30) goto <D.26923>; else goto <D.26909>;
  <D.26923>:
  D.26924 = klassc->interface_id;
  D.26925 = klass->max_interface_id;
  if (D.26924 <= D.26925) goto <D.26926>; else goto <D.26927>;
  <D.26926>:
  D.26928 = klass->interface_bitmap;
  D.26924 = klassc->interface_id;
  D.26929 = D.26924 >> 3;
  D.26930 = (sizetype) D.26929;
  D.26931 = D.26928 + D.26930;
  D.26932 = *D.26931;
  D.26933 = (int) D.26932;
  D.26924 = klassc->interface_id;
  D.26934 = (int) D.26924;
  D.26935 = D.26934 & 7;
  D.26936 = D.26933 >> D.26935;
  D.26937 = D.26936 & 1;
  if (D.26937 != 0) goto <D.26938>; else goto <D.26939>;
  <D.26938>:
  D.26940 = 1;
  return D.26940;
  <D.26939>:
  <D.26927>:
  goto <D.26911>;
  <D.26909>:
  if (check_interfaces != 0) goto <D.26945>; else goto <D.26941>;
  <D.26945>:
  D.26913 = klassc->flags;
  D.26914 = D.26913 & 32;
  if (D.26914 != 0) goto <D.26942>; else goto <D.26946>;
  <D.26946>:
  D.26916 = klassc->byval_arg.type;
  if (D.26916 == 19) goto <D.26942>; else goto <D.26947>;
  <D.26947>:
  D.26916 = klassc->byval_arg.type;
  if (D.26916 == 30) goto <D.26942>; else goto <D.26941>;
  <D.26942>:
  D.26918 = klass->flags;
  D.26919 = D.26918 & 32;
  if (D.26919 != 0) goto <D.26943>; else goto <D.26948>;
  <D.26948>:
  D.26921 = klass->byval_arg.type;
  if (D.26921 == 19) goto <D.26943>; else goto <D.26949>;
  <D.26949>:
  D.26921 = klass->byval_arg.type;
  if (D.26921 == 30) goto <D.26943>; else goto <D.26941>;
  <D.26943>:
  {
    int i;

    i = 0;
    goto <D.20699>;
    <D.20698>:
    {
      struct MonoClass * ic;

      D.26950 = klass->interfaces;
      D.26951 = (long unsigned int) i;
      D.26952 = D.26951 * 8;
      D.26953 = D.26950 + D.26952;
      ic = *D.26953;
      if (ic == klassc) goto <D.26954>; else goto <D.26955>;
      <D.26954>:
      D.26940 = 1;
      return D.26940;
      <D.26955>:
    }
    i = i + 1;
    <D.20699>:
    D.26956 = klass->interface_count;
    D.26957 = (int) D.26956;
    if (D.26957 > i) goto <D.20698>; else goto <D.20700>;
    <D.20700>:
  }
  goto <D.26944>;
  <D.26941>:
  D.26918 = klass->flags;
  D.26919 = D.26918 & 32;
  if (D.26919 == 0) goto <D.26958>; else goto <D.26959>;
  <D.26958>:
  D.26921 = klass->byval_arg.type;
  if (D.26921 != 19) goto <D.26960>; else goto <D.26961>;
  <D.26960>:
  D.26921 = klass->byval_arg.type;
  if (D.26921 != 30) goto <D.26962>; else goto <D.26963>;
  <D.26962>:
  D.26964 = mono_class_has_parent (klass, klassc);
  if (D.26964 != 0) goto <D.26965>; else goto <D.26966>;
  <D.26965>:
  D.26940 = 1;
  return D.26940;
  <D.26966>:
  <D.26963>:
  <D.26961>:
  <D.26959>:
  <D.26944>:
  <D.26911>:
  D.26967 = mono_defaults.object_class;
  if (D.26967 == klassc) goto <D.26968>; else goto <D.26969>;
  <D.26968>:
  D.26940 = 1;
  return D.26940;
  <D.26969>:
  D.26940 = 0;
  return D.26940;
}


mono_class_has_parent (struct MonoClass * klass, struct MonoClass * parent)
{
  struct MonoClass * * D.26971;
  _Bool D.26972;
  long int D.26973;
  long int D.26974;
  struct MonoClass * * D.26977;
  _Bool D.26978;
  long int D.26979;
  long int D.26980;
  gboolean D.26983;

  D.26971 = klass->supertypes;
  D.26972 = D.26971 == 0B;
  D.26973 = (long int) D.26972;
  D.26974 = __builtin_expect (D.26973, 0);
  if (D.26974 != 0) goto <D.26975>; else goto <D.26976>;
  <D.26975>:
  mono_class_setup_supertypes (klass);
  <D.26976>:
  D.26977 = parent->supertypes;
  D.26978 = D.26977 == 0B;
  D.26979 = (long int) D.26978;
  D.26980 = __builtin_expect (D.26979, 0);
  if (D.26980 != 0) goto <D.26981>; else goto <D.26982>;
  <D.26981>:
  mono_class_setup_supertypes (parent);
  <D.26982>:
  D.26983 = mono_class_has_parent_fast (klass, parent);
  return D.26983;
}


mono_class_has_parent_fast (struct MonoClass * klass, struct MonoClass * parent)
{
  gboolean D.26985;
  int iftmp.241;
  short unsigned int D.26989;
  short unsigned int D.26990;
  struct MonoClass * * D.26992;
  long unsigned int D.26993;
  long unsigned int D.26994;
  sizetype D.26995;
  struct MonoClass * * D.26996;
  struct MonoClass * D.26997;

  D.26989 = klass->idepth;
  D.26990 = parent->idepth;
  if (D.26989 >= D.26990) goto <D.26991>; else goto <D.26987>;
  <D.26991>:
  D.26992 = klass->supertypes;
  D.26990 = parent->idepth;
  D.26993 = (long unsigned int) D.26990;
  D.26994 = D.26993 * 8;
  D.26995 = D.26994 + 18446744073709551608;
  D.26996 = D.26992 + D.26995;
  D.26997 = *D.26996;
  if (D.26997 == parent) goto <D.26998>; else goto <D.26987>;
  <D.26998>:
  iftmp.241 = 1;
  goto <D.26988>;
  <D.26987>:
  iftmp.241 = 0;
  <D.26988>:
  D.26985 = iftmp.241;
  return D.26985;
}


__attribute__((visibility ("hidden")))
mono_class_has_variant_generic_params (struct MonoClass * klass)
{
  struct MonoGenericClass * D.27000;
  gboolean D.27003;
  struct MonoClass * D.27004;
  struct MonoGenericParamFull * D.27005;
  long unsigned int D.27006;
  long unsigned int D.27007;
  struct MonoGenericParamFull * D.27008;
  short unsigned int D.27009;
  int D.27010;
  int D.27011;
  <unnamed-signed:31> D.27014;
  int D.27015;
  int i;
  struct MonoGenericContainer * container;

  D.27000 = klass->generic_class;
  if (D.27000 == 0B) goto <D.27001>; else goto <D.27002>;
  <D.27001>:
  D.27003 = 0;
  return D.27003;
  <D.27002>:
  D.27000 = klass->generic_class;
  D.27004 = D.27000->container_class;
  container = D.27004->generic_container;
  i = 0;
  goto <D.20710>;
  <D.20709>:
  D.27005 = container->type_params;
  D.27006 = (long unsigned int) i;
  D.27007 = D.27006 * 56;
  D.27008 = D.27005 + D.27007;
  D.27009 = D.27008->info.flags;
  D.27010 = (int) D.27009;
  D.27011 = D.27010 & 3;
  if (D.27011 != 0) goto <D.27012>; else goto <D.27013>;
  <D.27012>:
  D.27003 = 1;
  return D.27003;
  <D.27013>:
  i = i + 1;
  <D.20710>:
  D.27014 = container->type_argc;
  D.27015 = (int) D.27014;
  if (D.27015 > i) goto <D.20709>; else goto <D.20711>;
  <D.20711>:
  D.27003 = 0;
  return D.27003;
}


__attribute__((visibility ("hidden")))
mono_class_is_variant_compatible (struct MonoClass * klass, struct MonoClass * oklass, gboolean check_for_reference_conv)
{
  gboolean D.27019;
  struct MonoClass * D.27022;
  struct MonoGenericClass * D.27024;
  struct MonoGenericInst * D.27025;
  struct MonoGenericClass * D.27026;
  struct MonoGenericInst * D.27027;
  long unsigned int D.27028;
  long unsigned int D.27029;
  struct MonoType * * D.27030;
  struct MonoType * D.27031;
  struct MonoType * * D.27032;
  struct MonoType * D.27033;
  long unsigned int D.27036;
  long unsigned int D.27037;
  long unsigned int D.27038;
  long unsigned int D.27039;
  long unsigned int D.27041;
  struct MonoGenericParamFull * D.27045;
  long unsigned int D.27046;
  struct MonoGenericParamFull * D.27047;
  short unsigned int D.27048;
  int D.27049;
  int D.27050;
  int D.27053;
  int D.27057;
  int D.27060;
  <unnamed-signed:31> D.27064;
  int D.27065;
  int j;
  struct MonoType * * klass_argv;
  struct MonoType * * oklass_argv;
  struct MonoClass * klass_gtd;
  struct MonoGenericContainer * container;

  klass_gtd = mono_class_get_generic_type_definition (klass);
  container = klass_gtd->generic_container;
  if (klass == oklass) goto <D.27017>; else goto <D.27018>;
  <D.27017>:
  D.27019 = 1;
  return D.27019;
  <D.27018>:
  D.27022 = mono_class_get_generic_type_definition (oklass);
  if (D.27022 != klass_gtd) goto <D.27020>; else goto <D.27023>;
  <D.27023>:
  if (oklass == klass_gtd) goto <D.27020>; else goto <D.27021>;
  <D.27020>:
  D.27019 = 0;
  return D.27019;
  <D.27021>:
  D.27024 = klass->generic_class;
  D.27025 = D.27024->context.class_inst;
  klass_argv = &D.27025->type_argv[0];
  D.27026 = oklass->generic_class;
  D.27027 = D.27026->context.class_inst;
  oklass_argv = &D.27027->type_argv[0];
  j = 0;
  goto <D.20732>;
  <D.20731>:
  {
    struct MonoClass * param1_class;
    struct MonoClass * param2_class;

    D.27028 = (long unsigned int) j;
    D.27029 = D.27028 * 8;
    D.27030 = klass_argv + D.27029;
    D.27031 = *D.27030;
    param1_class = mono_class_from_mono_type (D.27031);
    D.27028 = (long unsigned int) j;
    D.27029 = D.27028 * 8;
    D.27032 = oklass_argv + D.27029;
    D.27033 = *D.27032;
    param2_class = mono_class_from_mono_type (D.27033);
    D.27036 = BIT_FIELD_REF <*param1_class, 64, 256>;
    D.27037 = BIT_FIELD_REF <*param2_class, 64, 256>;
    D.27038 = D.27036 ^ D.27037;
    D.27039 = D.27038 & 1152921504606846976;
    if (D.27039 != 0) goto <D.27034>; else goto <D.27040>;
    <D.27040>:
    D.27036 = BIT_FIELD_REF <*param1_class, 64, 256>;
    D.27041 = D.27036 & 1152921504606846976;
    if (D.27041 != 0) goto <D.27042>; else goto <D.27035>;
    <D.27042>:
    if (param1_class != param2_class) goto <D.27034>; else goto <D.27035>;
    <D.27034>:
    D.27019 = 0;
    return D.27019;
    <D.27035>:
    if (param1_class != param2_class) goto <D.27043>; else goto <D.27044>;
    <D.27043>:
    D.27045 = container->type_params;
    D.27028 = (long unsigned int) j;
    D.27046 = D.27028 * 56;
    D.27047 = D.27045 + D.27046;
    D.27048 = D.27047->info.flags;
    D.27049 = (int) D.27048;
    D.27050 = D.27049 & 1;
    if (D.27050 != 0) goto <D.27051>; else goto <D.27052>;
    <D.27051>:
    D.27053 = mono_gparam_is_reference_conversible (param1_class, param2_class, check_for_reference_conv);
    if (D.27053 == 0) goto <D.27054>; else goto <D.27055>;
    <D.27054>:
    D.27019 = 0;
    return D.27019;
    <D.27055>:
    goto <D.27056>;
    <D.27052>:
    D.27045 = container->type_params;
    D.27028 = (long unsigned int) j;
    D.27046 = D.27028 * 56;
    D.27047 = D.27045 + D.27046;
    D.27048 = D.27047->info.flags;
    D.27049 = (int) D.27048;
    D.27057 = D.27049 & 2;
    if (D.27057 != 0) goto <D.27058>; else goto <D.27059>;
    <D.27058>:
    D.27060 = mono_gparam_is_reference_conversible (param2_class, param1_class, check_for_reference_conv);
    if (D.27060 == 0) goto <D.27061>; else goto <D.27062>;
    <D.27061>:
    D.27019 = 0;
    return D.27019;
    <D.27062>:
    goto <D.27063>;
    <D.27059>:
    D.27019 = 0;
    return D.27019;
    <D.27063>:
    <D.27056>:
    <D.27044>:
  }
  j = j + 1;
  <D.20732>:
  D.27064 = container->type_argc;
  D.27065 = (int) D.27064;
  if (D.27065 > j) goto <D.20731>; else goto <D.20733>;
  <D.20733>:
  D.27019 = 1;
  return D.27019;
}


mono_gparam_is_reference_conversible (struct MonoClass * target, struct MonoClass * candidate, gboolean check_for_reference_conv)
{
  gboolean D.27069;
  struct MonoType * D.27072;
  int D.27073;
  struct MonoType * D.27076;
  int D.27077;
  struct MonoGenericParamInfo * iftmp.242;
  struct MonoGenericContainer * D.27081;
  short unsigned int D.27088;
  int D.27089;
  int D.27090;
  int D.27091;

  if (target == candidate) goto <D.27067>; else goto <D.27068>;
  <D.27067>:
  D.27069 = 1;
  return D.27069;
  <D.27068>:
  if (check_for_reference_conv != 0) goto <D.27070>; else goto <D.27071>;
  <D.27070>:
  D.27072 = &target->byval_arg;
  D.27073 = mono_type_is_generic_argument (D.27072);
  if (D.27073 != 0) goto <D.27074>; else goto <D.27075>;
  <D.27074>:
  D.27076 = &candidate->byval_arg;
  D.27077 = mono_type_is_generic_argument (D.27076);
  if (D.27077 != 0) goto <D.27078>; else goto <D.27079>;
  <D.27078>:
  {
    struct MonoGenericParam * gparam;
    struct MonoGenericParamInfo * pinfo;

    gparam = candidate->byval_arg.data.generic_param;
    D.27081 = gparam->owner;
    if (D.27081 != 0B) goto <D.27082>; else goto <D.27083>;
    <D.27082>:
    iftmp.242 = &MEM[(struct MonoGenericParamFull *)gparam].info;
    goto <D.27084>;
    <D.27083>:
    iftmp.242 = 0B;
    <D.27084>:
    pinfo = iftmp.242;
    if (pinfo == 0B) goto <D.27085>; else goto <D.27087>;
    <D.27087>:
    D.27088 = pinfo->flags;
    D.27089 = (int) D.27088;
    D.27090 = D.27089 & 4;
    if (D.27090 == 0) goto <D.27085>; else goto <D.27086>;
    <D.27085>:
    D.27069 = 0;
    return D.27069;
    <D.27086>:
  }
  <D.27079>:
  <D.27075>:
  <D.27071>:
  D.27091 = mono_class_is_assignable_from (target, candidate);
  if (D.27091 == 0) goto <D.27092>; else goto <D.27093>;
  <D.27092>:
  D.27069 = 0;
  return D.27069;
  <D.27093>:
  D.27069 = 1;
  return D.27069;
}


mono_type_is_generic_argument (struct MonoType * type)
{
  gboolean D.27095;
  int iftmp.243;
  unsigned char D.27100;

  D.27100 = type->type;
  if (D.27100 == 19) goto <D.27097>; else goto <D.27101>;
  <D.27101>:
  D.27100 = type->type;
  if (D.27100 == 30) goto <D.27097>; else goto <D.27098>;
  <D.27097>:
  iftmp.243 = 1;
  goto <D.27099>;
  <D.27098>:
  iftmp.243 = 0;
  <D.27099>:
  D.27095 = iftmp.243;
  return D.27095;
}


mono_class_is_assignable_from (struct MonoClass * klass, struct MonoClass * oklass)
{
  long unsigned int D.27103;
  long unsigned int D.27104;
  long unsigned int D.27107;
  long unsigned int D.27108;
  unsigned char D.27113;
  unsigned char D.27115;
  mono_bool D.27116;
  struct MonoType * D.27117;
  int D.27118;
  struct MonoType * D.27121;
  int D.27122;
  unsigned int D.27127;
  unsigned int D.27128;
  unsigned char D.27130;
  unsigned char D.27134;
  struct MonoGenericContainer * D.27136;
  struct MonoGenericParamFull * D.27137;
  short unsigned int D.27138;
  long unsigned int D.27139;
  long unsigned int D.27140;
  struct MonoGenericParamFull * D.27141;
  long unsigned int D.27144;
  long unsigned int D.27145;
  struct MonoClass * * D.27146;
  struct MonoClass * D.27147;
  int D.27148;
  unsigned int D.27151;
  guint8 * D.27154;
  short unsigned int D.27159;
  short unsigned int D.27160;
  short unsigned int D.27163;
  sizetype D.27164;
  guint8 * D.27165;
  unsigned char D.27166;
  int D.27167;
  int D.27168;
  int D.27169;
  int D.27170;
  int D.27171;
  int D.27174;
  int D.27177;
  struct MonoClass * * D.27180;
  long unsigned int D.27181;
  long unsigned int D.27182;
  struct MonoClass * * D.27183;
  int D.27184;
  short unsigned int D.27187;
  int D.27188;
  long unsigned int D.27189;
  int D.27192;
  int D.27195;
  unsigned char D.27199;
  unsigned char D.27202;
  long unsigned int D.27207;
  long unsigned int D.27208;
  struct MonoClass * D.27213;
  struct MonoClass * D.27215;
  struct MonoClass * D.27217;
  struct MonoClass * D.27218;
  struct MonoClass * D.27219;
  int D.27220;
  int D.27223;

  D.27103 = BIT_FIELD_REF <*klass, 64, 256>;
  D.27104 = D.27103 & 9223372036854775808;
  if (D.27104 == 0) goto <D.27105>; else goto <D.27106>;
  <D.27105>:
  mono_class_init (klass);
  <D.27106>:
  D.27107 = BIT_FIELD_REF <*oklass, 64, 256>;
  D.27108 = D.27107 & 9223372036854775808;
  if (D.27108 == 0) goto <D.27109>; else goto <D.27110>;
  <D.27109>:
  mono_class_init (oklass);
  <D.27110>:
  D.27113 = klass->exception_type;
  if (D.27113 != 0) goto <D.27111>; else goto <D.27114>;
  <D.27114>:
  D.27115 = oklass->exception_type;
  if (D.27115 != 0) goto <D.27111>; else goto <D.27112>;
  <D.27111>:
  D.27116 = 0;
  return D.27116;
  <D.27112>:
  D.27117 = &klass->byval_arg;
  D.27118 = mono_type_is_generic_argument (D.27117);
  if (D.27118 != 0) goto <D.27119>; else goto <D.27120>;
  <D.27119>:
  D.27121 = &oklass->byval_arg;
  D.27122 = mono_type_is_generic_argument (D.27121);
  if (D.27122 == 0) goto <D.27123>; else goto <D.27124>;
  <D.27123>:
  D.27116 = 0;
  return D.27116;
  <D.27124>:
  D.27116 = mono_gparam_is_assignable_from (klass, oklass);
  return D.27116;
  <D.27120>:
  D.27127 = klass->flags;
  D.27128 = D.27127 & 32;
  if (D.27128 != 0) goto <D.27125>; else goto <D.27129>;
  <D.27129>:
  D.27130 = klass->byval_arg.type;
  if (D.27130 == 19) goto <D.27125>; else goto <D.27131>;
  <D.27131>:
  D.27130 = klass->byval_arg.type;
  if (D.27130 == 30) goto <D.27125>; else goto <D.27126>;
  <D.27125>:
  D.27134 = oklass->byval_arg.type;
  if (D.27134 == 19) goto <D.27132>; else goto <D.27135>;
  <D.27135>:
  D.27134 = oklass->byval_arg.type;
  if (D.27134 == 30) goto <D.27132>; else goto <D.27133>;
  <D.27132>:
  {
    struct MonoGenericParam * gparam;
    struct MonoClass * * constraints;
    int i;

    gparam = oklass->byval_arg.data.generic_param;
    D.27136 = gparam->owner;
    D.27137 = D.27136->type_params;
    D.27138 = gparam->num;
    D.27139 = (long unsigned int) D.27138;
    D.27140 = D.27139 * 56;
    D.27141 = D.27137 + D.27140;
    constraints = D.27141->info.constraints;
    if (constraints != 0B) goto <D.27142>; else goto <D.27143>;
    <D.27142>:
    i = 0;
    goto <D.20773>;
    <D.20772>:
    D.27144 = (long unsigned int) i;
    D.27145 = D.27144 * 8;
    D.27146 = constraints + D.27145;
    D.27147 = *D.27146;
    D.27148 = mono_class_is_assignable_from (klass, D.27147);
    if (D.27148 != 0) goto <D.27149>; else goto <D.27150>;
    <D.27149>:
    D.27116 = 1;
    return D.27116;
    <D.27150>:
    i = i + 1;
    <D.20773>:
    D.27144 = (long unsigned int) i;
    D.27145 = D.27144 * 8;
    D.27146 = constraints + D.27145;
    D.27147 = *D.27146;
    if (D.27147 != 0B) goto <D.20772>; else goto <D.20774>;
    <D.20774>:
    <D.27143>:
    D.27116 = 0;
    return D.27116;
  }
  <D.27133>:
  D.27151 = oklass->ref_info_handle;
  if (D.27151 != 0) goto <D.27152>; else goto <D.27153>;
  <D.27152>:
  D.27154 = oklass->interface_bitmap;
  if (D.27154 == 0B) goto <D.27155>; else goto <D.27156>;
  <D.27155>:
  D.27116 = mono_reflection_call_is_assignable_to (oklass, klass);
  return D.27116;
  <D.27156>:
  <D.27153>:
  D.27154 = oklass->interface_bitmap;
  if (D.27154 == 0B) goto <D.27157>; else goto <D.27158>;
  <D.27157>:
  D.27116 = 0;
  return D.27116;
  <D.27158>:
  D.27159 = klass->interface_id;
  D.27160 = oklass->max_interface_id;
  if (D.27159 <= D.27160) goto <D.27161>; else goto <D.27162>;
  <D.27161>:
  D.27154 = oklass->interface_bitmap;
  D.27159 = klass->interface_id;
  D.27163 = D.27159 >> 3;
  D.27164 = (sizetype) D.27163;
  D.27165 = D.27154 + D.27164;
  D.27166 = *D.27165;
  D.27167 = (int) D.27166;
  D.27159 = klass->interface_id;
  D.27168 = (int) D.27159;
  D.27169 = D.27168 & 7;
  D.27170 = D.27167 >> D.27169;
  D.27171 = D.27170 & 1;
  if (D.27171 != 0) goto <D.27172>; else goto <D.27173>;
  <D.27172>:
  D.27116 = 1;
  return D.27116;
  <D.27173>:
  <D.27162>:
  D.27174 = mono_class_has_variant_generic_params (klass);
  if (D.27174 != 0) goto <D.27175>; else goto <D.27176>;
  <D.27175>:
  {
    struct MonoError error;
    int i;

    try
      {
        mono_class_setup_interfaces (oklass, &error);
        D.27177 = mono_error_ok (&error);
        if (D.27177 == 0) goto <D.27178>; else goto <D.27179>;
        <D.27178>:
        mono_error_cleanup (&error);
        D.27116 = 0;
        return D.27116;
        <D.27179>:
        i = 0;
        goto <D.20779>;
        <D.20778>:
        {
          struct MonoClass * iface;

          D.27180 = oklass->interfaces_packed;
          D.27181 = (long unsigned int) i;
          D.27182 = D.27181 * 8;
          D.27183 = D.27180 + D.27182;
          iface = *D.27183;
          D.27184 = mono_class_is_variant_compatible (klass, iface, 0);
          if (D.27184 != 0) goto <D.27185>; else goto <D.27186>;
          <D.27185>:
          D.27116 = 1;
          return D.27116;
          <D.27186>:
        }
        i = i + 1;
        <D.20779>:
        D.27187 = oklass->interface_offsets_count;
        D.27188 = (int) D.27187;
        if (D.27188 > i) goto <D.20778>; else goto <D.20780>;
        <D.20780>:
      }
    finally
      {
        error = {CLOBBER};
      }
  }
  <D.27176>:
  D.27116 = 0;
  return D.27116;
  <D.27126>:
  D.27103 = BIT_FIELD_REF <*klass, 64, 256>;
  D.27189 = D.27103 & 549755813888;
  if (D.27189 != 0) goto <D.27190>; else goto <D.27191>;
  <D.27190>:
  D.27192 = mono_class_has_variant_generic_params (klass);
  if (D.27192 != 0) goto <D.27193>; else goto <D.27194>;
  <D.27193>:
  D.27195 = mono_class_is_variant_compatible (klass, oklass, 0);
  if (D.27195 != 0) goto <D.27196>; else goto <D.27197>;
  <D.27196>:
  D.27116 = 1;
  return D.27116;
  <D.27197>:
  <D.27194>:
  goto <D.27198>;
  <D.27191>:
  D.27199 = klass->rank;
  if (D.27199 != 0) goto <D.27200>; else goto <D.27201>;
  <D.27200>:
  {
    struct MonoClass * eclass;
    struct MonoClass * eoclass;

    D.27202 = oklass->rank;
    D.27199 = klass->rank;
    if (D.27202 != D.27199) goto <D.27203>; else goto <D.27204>;
    <D.27203>:
    D.27116 = 0;
    return D.27116;
    <D.27204>:
    D.27134 = oklass->byval_arg.type;
    D.27130 = klass->byval_arg.type;
    if (D.27134 != D.27130) goto <D.27205>; else goto <D.27206>;
    <D.27205>:
    D.27116 = 0;
    return D.27116;
    <D.27206>:
    eclass = klass->cast_class;
    eoclass = oklass->cast_class;
    D.27207 = BIT_FIELD_REF <*eoclass, 64, 256>;
    D.27208 = D.27207 & 1152921504606846976;
    if (D.27208 != 0) goto <D.27209>; else goto <D.27210>;
    <D.27209>:
    D.27213 = mono_defaults.enum_class;
    if (D.27213 == eclass) goto <D.27211>; else goto <D.27214>;
    <D.27214>:
    D.27213 = mono_defaults.enum_class;
    D.27215 = D.27213->parent;
    if (D.27215 == eclass) goto <D.27211>; else goto <D.27216>;
    <D.27216>:
    D.27217 = mono_defaults.object_class;
    if (D.27217 == eclass) goto <D.27211>; else goto <D.27212>;
    <D.27211>:
    D.27116 = 0;
    return D.27116;
    <D.27212>:
    <D.27210>:
    D.27218 = klass->cast_class;
    D.27219 = oklass->cast_class;
    D.27116 = mono_class_is_assignable_from (D.27218, D.27219);
    return D.27116;
  }
  <D.27201>:
  D.27220 = mono_class_is_nullable (klass);
  if (D.27220 != 0) goto <D.27221>; else goto <D.27222>;
  <D.27221>:
  D.27223 = mono_class_is_nullable (oklass);
  if (D.27223 != 0) goto <D.27224>; else goto <D.27225>;
  <D.27224>:
  D.27218 = klass->cast_class;
  D.27219 = oklass->cast_class;
  D.27116 = mono_class_is_assignable_from (D.27218, D.27219);
  return D.27116;
  <D.27225>:
  D.27218 = klass->cast_class;
  D.27116 = mono_class_is_assignable_from (D.27218, oklass);
  return D.27116;
  <D.27222>:
  D.27217 = mono_defaults.object_class;
  if (D.27217 == klass) goto <D.27226>; else goto <D.27227>;
  <D.27226>:
  D.27116 = 1;
  return D.27116;
  <D.27227>:
  <D.27198>:
  D.27116 = mono_class_has_parent (oklass, klass);
  return D.27116;
}


mono_gparam_is_assignable_from (struct MonoClass * target, struct MonoClass * candidate)
{
  gboolean D.27233;
  unsigned char D.27234;
  unsigned char D.27235;
  struct MonoGenericParamInfo * iftmp.244;
  struct MonoGenericContainer * D.27239;
  struct MonoGenericParamInfo * iftmp.245;
  struct MonoGenericContainer * D.27244;
  short unsigned int D.27248;
  int D.27249;
  short unsigned int D.27250;
  int D.27251;
  struct MonoClass * * D.27252;
  struct MonoType * D.27257;
  int D.27258;
  unsigned int D.27260;
  unsigned int D.27261;
  unsigned char D.27263;
  int D.27266;
  struct MonoClass * D.27275;
  int D.27276;
  _Bool D.27277;
  int D.27278;
  int D.27279;
  _Bool D.27280;
  int D.27281;
  int D.27282;
  int D.27287;
  int D.27292;
  int D.27295;
  struct MonoClass * * D.27300;
  struct MonoType * D.27303;
  struct MonoType * D.27304;
  int D.27305;
  int D.27310;
  struct MonoType * D.27312;
  int D.27313;
  int D.27316;
  struct MonoClass * D.27320;
  int D.27323;
  struct MonoGenericParam * gparam;
  struct MonoGenericParam * ogparam;
  struct MonoGenericParamInfo * tinfo;
  struct MonoGenericParamInfo * cinfo;
  struct MonoClass * * candidate_class;
  gboolean class_constraint_satisfied;
  gboolean valuetype_constraint_satisfied;
  int tmask;
  int cmask;

  if (target == candidate) goto <D.27231>; else goto <D.27232>;
  <D.27231>:
  D.27233 = 1;
  return D.27233;
  <D.27232>:
  D.27234 = target->byval_arg.type;
  D.27235 = candidate->byval_arg.type;
  if (D.27234 != D.27235) goto <D.27236>; else goto <D.27237>;
  <D.27236>:
  D.27233 = 0;
  return D.27233;
  <D.27237>:
  gparam = target->byval_arg.data.generic_param;
  ogparam = candidate->byval_arg.data.generic_param;
  D.27239 = gparam->owner;
  if (D.27239 != 0B) goto <D.27240>; else goto <D.27241>;
  <D.27240>:
  iftmp.244 = &MEM[(struct MonoGenericParamFull *)gparam].info;
  goto <D.27242>;
  <D.27241>:
  iftmp.244 = 0B;
  <D.27242>:
  tinfo = iftmp.244;
  D.27244 = ogparam->owner;
  if (D.27244 != 0B) goto <D.27245>; else goto <D.27246>;
  <D.27245>:
  iftmp.245 = &MEM[(struct MonoGenericParamFull *)ogparam].info;
  goto <D.27247>;
  <D.27246>:
  iftmp.245 = 0B;
  <D.27247>:
  cinfo = iftmp.245;
  class_constraint_satisfied = 0;
  valuetype_constraint_satisfied = 0;
  D.27248 = tinfo->flags;
  D.27249 = (int) D.27248;
  tmask = D.27249 & 28;
  D.27250 = cinfo->flags;
  D.27251 = (int) D.27250;
  cmask = D.27251 & 28;
  D.27252 = cinfo->constraints;
  if (D.27252 != 0B) goto <D.27253>; else goto <D.27254>;
  <D.27253>:
  candidate_class = cinfo->constraints;
  goto <D.20749>;
  <D.20748>:
  {
    struct MonoClass * cc;

    cc = *candidate_class;
    D.27257 = &cc->byval_arg;
    D.27258 = mono_type_is_reference (D.27257);
    if (D.27258 != 0) goto <D.27259>; else goto <D.27255>;
    <D.27259>:
    D.27260 = cc->flags;
    D.27261 = D.27260 & 32;
    if (D.27261 == 0) goto <D.27262>; else goto <D.27255>;
    <D.27262>:
    D.27263 = cc->byval_arg.type;
    if (D.27263 != 19) goto <D.27264>; else goto <D.27255>;
    <D.27264>:
    D.27263 = cc->byval_arg.type;
    if (D.27263 != 30) goto <D.27265>; else goto <D.27255>;
    <D.27265>:
    class_constraint_satisfied = 1;
    goto <D.27256>;
    <D.27255>:
    D.27257 = &cc->byval_arg;
    D.27266 = mono_type_is_reference (D.27257);
    if (D.27266 == 0) goto <D.27267>; else goto <D.27268>;
    <D.27267>:
    D.27260 = cc->flags;
    D.27261 = D.27260 & 32;
    if (D.27261 == 0) goto <D.27269>; else goto <D.27270>;
    <D.27269>:
    D.27263 = cc->byval_arg.type;
    if (D.27263 != 19) goto <D.27271>; else goto <D.27272>;
    <D.27271>:
    D.27263 = cc->byval_arg.type;
    if (D.27263 != 30) goto <D.27273>; else goto <D.27274>;
    <D.27273>:
    valuetype_constraint_satisfied = 1;
    <D.27274>:
    <D.27272>:
    <D.27270>:
    <D.27268>:
    <D.27256>:
  }
  candidate_class = candidate_class + 8;
  <D.20749>:
  D.27275 = *candidate_class;
  if (D.27275 != 0B) goto <D.20748>; else goto <D.20750>;
  <D.20750>:
  <D.27254>:
  D.27276 = cmask & 4;
  D.27277 = D.27276 != 0;
  D.27278 = (int) D.27277;
  class_constraint_satisfied = D.27278 | class_constraint_satisfied;
  D.27279 = cmask & 8;
  D.27280 = D.27279 != 0;
  D.27281 = (int) D.27280;
  valuetype_constraint_satisfied = D.27281 | valuetype_constraint_satisfied;
  D.27282 = tmask & 4;
  if (D.27282 != 0) goto <D.27283>; else goto <D.27284>;
  <D.27283>:
  if (class_constraint_satisfied == 0) goto <D.27285>; else goto <D.27286>;
  <D.27285>:
  D.27233 = 0;
  return D.27233;
  <D.27286>:
  <D.27284>:
  D.27287 = tmask & 8;
  if (D.27287 != 0) goto <D.27288>; else goto <D.27289>;
  <D.27288>:
  if (valuetype_constraint_satisfied == 0) goto <D.27290>; else goto <D.27291>;
  <D.27290>:
  D.27233 = 0;
  return D.27233;
  <D.27291>:
  <D.27289>:
  D.27292 = tmask & 16;
  if (D.27292 != 0) goto <D.27293>; else goto <D.27294>;
  <D.27293>:
  D.27295 = cmask & 16;
  if (D.27295 == 0) goto <D.27296>; else goto <D.27297>;
  <D.27296>:
  if (valuetype_constraint_satisfied == 0) goto <D.27298>; else goto <D.27299>;
  <D.27298>:
  D.27233 = 0;
  return D.27233;
  <D.27299>:
  <D.27297>:
  <D.27294>:
  D.27300 = tinfo->constraints;
  if (D.27300 != 0B) goto <D.27301>; else goto <D.27302>;
  <D.27301>:
  {
    struct MonoClass * * target_class;

    target_class = tinfo->constraints;
    goto <D.20759>;
    <D.20758>:
    {
      struct MonoClass * tc;

      tc = *target_class;
      D.27303 = &tc->byval_arg;
      D.27304 = &candidate->byval_arg;
      D.27305 = mono_metadata_type_equal (D.27303, D.27304);
      if (D.27305 != 0) goto <D.27306>; else goto <D.27307>;
      <D.27306>:
      // predicted unlikely by continue predictor.
      goto <D.20753>;
      <D.27307>:
      D.27252 = cinfo->constraints;
      if (D.27252 == 0B) goto <D.27308>; else goto <D.27309>;
      <D.27308>:
      D.27233 = 0;
      return D.27233;
      <D.27309>:
      candidate_class = cinfo->constraints;
      goto <D.20757>;
      <D.20756>:
      {
        struct MonoClass * cc;

        cc = *candidate_class;
        D.27310 = mono_class_is_assignable_from (tc, cc);
        if (D.27310 != 0) goto <D.20755>; else goto <D.27311>;
        <D.27311>:
        D.27312 = &cc->byval_arg;
        D.27313 = mono_type_is_generic_argument (D.27312);
        if (D.27313 != 0) goto <D.27314>; else goto <D.27315>;
        <D.27314>:
        D.27316 = mono_gparam_is_assignable_from (target, cc);
        if (D.27316 != 0) goto <D.20755>; else goto <D.27317>;
        <D.27317>:
        <D.27315>:
      }
      candidate_class = candidate_class + 8;
      <D.20757>:
      D.27275 = *candidate_class;
      if (D.27275 != 0B) goto <D.20756>; else goto <D.20755>;
      <D.20755>:
      D.27275 = *candidate_class;
      if (D.27275 == 0B) goto <D.27318>; else goto <D.27319>;
      <D.27318>:
      D.27233 = 0;
      return D.27233;
      <D.27319>:
    }
    <D.20753>:
    target_class = target_class + 8;
    <D.20759>:
    D.27320 = *target_class;
    if (D.27320 != 0B) goto <D.20758>; else goto <D.20760>;
    <D.20760>:
  }
  <D.27302>:
  D.27252 = cinfo->constraints;
  if (D.27252 != 0B) goto <D.27321>; else goto <D.27322>;
  <D.27321>:
  candidate_class = cinfo->constraints;
  goto <D.20763>;
  <D.20762>:
  {
    struct MonoClass * cc;

    cc = *candidate_class;
    D.27323 = mono_class_is_assignable_from (target, cc);
    if (D.27323 != 0) goto <D.27324>; else goto <D.27325>;
    <D.27324>:
    D.27233 = 1;
    return D.27233;
    <D.27325>:
  }
  candidate_class = candidate_class + 8;
  <D.20763>:
  D.27275 = *candidate_class;
  if (D.27275 != 0B) goto <D.20762>; else goto <D.20764>;
  <D.20764>:
  <D.27322>:
  D.27233 = 0;
  return D.27233;
}


__attribute__((visibility ("hidden")))
mono_class_is_assignable_from_slow (struct MonoClass * target, struct MonoClass * candidate)
{
  gboolean D.27329;
  struct MonoClass * D.27330;
  int D.27333;
  unsigned int D.27338;
  unsigned int D.27339;
  unsigned char D.27341;
  long unsigned int D.27343;
  long unsigned int D.27344;
  int D.27347;
  unsigned char D.27350;
  unsigned char D.27353;
  unsigned char D.27356;
  long unsigned int D.27359;
  long unsigned int D.27360;
  struct MonoClass * D.27365;
  struct MonoClass * D.27367;
  struct MonoClass * D.27369;
  struct MonoClass * D.27370;

  if (candidate == target) goto <D.27327>; else goto <D.27328>;
  <D.27327>:
  D.27329 = 1;
  return D.27329;
  <D.27328>:
  D.27330 = mono_defaults.object_class;
  if (D.27330 == target) goto <D.27331>; else goto <D.27332>;
  <D.27331>:
  D.27329 = 1;
  return D.27329;
  <D.27332>:
  D.27333 = mono_class_has_parent (candidate, target);
  if (D.27333 != 0) goto <D.27334>; else goto <D.27335>;
  <D.27334>:
  D.27329 = 1;
  return D.27329;
  <D.27335>:
  D.27338 = target->flags;
  D.27339 = D.27338 & 32;
  if (D.27339 != 0) goto <D.27336>; else goto <D.27340>;
  <D.27340>:
  D.27341 = target->byval_arg.type;
  if (D.27341 == 19) goto <D.27336>; else goto <D.27342>;
  <D.27342>:
  D.27341 = target->byval_arg.type;
  if (D.27341 == 30) goto <D.27336>; else goto <D.27337>;
  <D.27336>:
  D.27329 = mono_class_implement_interface_slow (target, candidate);
  return D.27329;
  <D.27337>:
  D.27343 = BIT_FIELD_REF <*target, 64, 256>;
  D.27344 = D.27343 & 549755813888;
  if (D.27344 != 0) goto <D.27345>; else goto <D.27346>;
  <D.27345>:
  D.27347 = mono_class_has_variant_generic_params (target);
  if (D.27347 != 0) goto <D.27348>; else goto <D.27349>;
  <D.27348>:
  D.27329 = mono_class_is_variant_compatible (target, candidate, 0);
  return D.27329;
  <D.27349>:
  <D.27346>:
  D.27350 = target->rank;
  if (D.27350 != 0) goto <D.27351>; else goto <D.27352>;
  <D.27351>:
  {
    struct MonoClass * eclass;
    struct MonoClass * eoclass;

    D.27350 = target->rank;
    D.27353 = candidate->rank;
    if (D.27350 != D.27353) goto <D.27354>; else goto <D.27355>;
    <D.27354>:
    D.27329 = 0;
    return D.27329;
    <D.27355>:
    D.27341 = target->byval_arg.type;
    D.27356 = candidate->byval_arg.type;
    if (D.27341 != D.27356) goto <D.27357>; else goto <D.27358>;
    <D.27357>:
    D.27329 = 0;
    return D.27329;
    <D.27358>:
    eclass = target->cast_class;
    eoclass = candidate->cast_class;
    D.27359 = BIT_FIELD_REF <*eoclass, 64, 256>;
    D.27360 = D.27359 & 1152921504606846976;
    if (D.27360 != 0) goto <D.27361>; else goto <D.27362>;
    <D.27361>:
    D.27365 = mono_defaults.enum_class;
    if (D.27365 == eclass) goto <D.27363>; else goto <D.27366>;
    <D.27366>:
    D.27365 = mono_defaults.enum_class;
    D.27367 = D.27365->parent;
    if (D.27367 == eclass) goto <D.27363>; else goto <D.27368>;
    <D.27368>:
    D.27330 = mono_defaults.object_class;
    if (D.27330 == eclass) goto <D.27363>; else goto <D.27364>;
    <D.27363>:
    D.27329 = 0;
    return D.27329;
    <D.27364>:
    <D.27362>:
    D.27369 = target->cast_class;
    D.27370 = candidate->cast_class;
    D.27329 = mono_class_is_assignable_from_slow (D.27369, D.27370);
    return D.27329;
  }
  <D.27352>:
  D.27329 = 0;
  return D.27329;
}


mono_class_implement_interface_slow (struct MonoClass * target, struct MonoClass * candidate)
{
  unsigned int D.27376;
  unsigned int D.27377;
  unsigned char D.27379;
  int D.27381;
  gboolean D.27384;
  struct MonoImage * D.27388;
  long unsigned int D.27389;
  long unsigned int D.27390;
  long unsigned int D.27392;
  long unsigned int D.27393;
  struct MonoArray * D.27397;
  long unsigned int D.27400;
  unsigned int D.27401;
  unsigned int D.27402;
  long unsigned int D.27403;
  char * D.27404;
  struct MonoType * D.27405;
  int D.27412;
  int D.27415;
  int D.27418;
  struct MonoClass * * D.27421;
  long unsigned int D.27422;
  long unsigned int D.27423;
  struct MonoClass * * D.27424;
  struct MonoClass * D.27425;
  int D.27430;
  int D.27433;
  short unsigned int D.27436;
  int D.27437;
  struct MonoError error;
  int i;
  gboolean is_variant;

  try
    {
      is_variant = mono_class_has_variant_generic_params (target);
      if (is_variant != 0) goto <D.27374>; else goto <D.27375>;
      <D.27374>:
      D.27376 = candidate->flags;
      D.27377 = D.27376 & 32;
      if (D.27377 != 0) goto <D.27372>; else goto <D.27378>;
      <D.27378>:
      D.27379 = candidate->byval_arg.type;
      if (D.27379 == 19) goto <D.27372>; else goto <D.27380>;
      <D.27380>:
      D.27379 = candidate->byval_arg.type;
      if (D.27379 == 30) goto <D.27372>; else goto <D.27373>;
      <D.27372>:
      D.27381 = mono_class_is_variant_compatible_slow (target, candidate);
      if (D.27381 != 0) goto <D.27382>; else goto <D.27383>;
      <D.27382>:
      D.27384 = 1;
      return D.27384;
      <D.27383>:
      <D.27373>:
      <D.27375>:
      <D.20815>:
      if (candidate == target) goto <D.27385>; else goto <D.27386>;
      <D.27385>:
      D.27384 = 1;
      return D.27384;
      <D.27386>:
      D.27388 = candidate->image;
      D.27389 = BIT_FIELD_REF <*D.27388, 64, 192>;
      D.27390 = D.27389 & 268435456;
      if (D.27390 != 0) goto <D.27391>; else goto <D.27387>;
      <D.27391>:
      D.27392 = BIT_FIELD_REF <*candidate, 64, 256>;
      D.27393 = D.27392 & 72057594037927936;
      if (D.27393 == 0) goto <D.27394>; else goto <D.27387>;
      <D.27394>:
      {
        struct MonoReflectionTypeBuilder * tb;
        int j;

        tb = mono_class_get_ref_info (candidate);
        if (tb != 0B) goto <D.27395>; else goto <D.27396>;
        <D.27395>:
        D.27397 = tb->interfaces;
        if (D.27397 != 0B) goto <D.27398>; else goto <D.27399>;
        <D.27398>:
        D.27397 = tb->interfaces;
        D.27400 = mono_array_length (D.27397);
        D.27401 = (unsigned int) D.27400;
        D.27402 = D.27401 + 4294967295;
        j = (int) D.27402;
        goto <D.20810>;
        <D.20809>:
        {
          struct MonoReflectionType * iface;
          struct MonoClass * iface_class;

          D.27397 = tb->interfaces;
          D.27403 = (long unsigned int) j;
          D.27404 = mono_array_addr_with_size (D.27397, 8, D.27403);
          iface = MEM[(struct MonoReflectionType * *)D.27404];
          D.27405 = iface->type;
          if (D.27405 == 0B) goto <D.27406>; else goto <D.27407>;
          <D.27406>:
          // predicted unlikely by continue predictor.
          goto <D.20808>;
          <D.27407>:
          D.27405 = iface->type;
          iface_class = mono_class_from_mono_type (D.27405);
          if (iface_class == target) goto <D.27408>; else goto <D.27409>;
          <D.27408>:
          D.27384 = 1;
          return D.27384;
          <D.27409>:
          if (is_variant != 0) goto <D.27410>; else goto <D.27411>;
          <D.27410>:
          D.27412 = mono_class_is_variant_compatible_slow (target, iface_class);
          if (D.27412 != 0) goto <D.27413>; else goto <D.27414>;
          <D.27413>:
          D.27384 = 1;
          return D.27384;
          <D.27414>:
          <D.27411>:
          D.27415 = mono_class_implement_interface_slow (target, iface_class);
          if (D.27415 != 0) goto <D.27416>; else goto <D.27417>;
          <D.27416>:
          D.27384 = 1;
          return D.27384;
          <D.27417>:
        }
        <D.20808>:
        j = j + -1;
        <D.20810>:
        if (j >= 0) goto <D.20809>; else goto <D.20811>;
        <D.20811>:
        <D.27399>:
        <D.27396>:
      }
      goto <D.20814>;
      <D.27387>:
      mono_class_setup_interfaces (candidate, &error);
      D.27418 = mono_error_ok (&error);
      if (D.27418 == 0) goto <D.27419>; else goto <D.27420>;
      <D.27419>:
      mono_error_cleanup (&error);
      D.27384 = 0;
      return D.27384;
      <D.27420>:
      i = 0;
      goto <D.20813>;
      <D.20812>:
      D.27421 = candidate->interfaces;
      D.27422 = (long unsigned int) i;
      D.27423 = D.27422 * 8;
      D.27424 = D.27421 + D.27423;
      D.27425 = *D.27424;
      if (D.27425 == target) goto <D.27426>; else goto <D.27427>;
      <D.27426>:
      D.27384 = 1;
      return D.27384;
      <D.27427>:
      if (is_variant != 0) goto <D.27428>; else goto <D.27429>;
      <D.27428>:
      D.27421 = candidate->interfaces;
      D.27422 = (long unsigned int) i;
      D.27423 = D.27422 * 8;
      D.27424 = D.27421 + D.27423;
      D.27425 = *D.27424;
      D.27430 = mono_class_is_variant_compatible_slow (target, D.27425);
      if (D.27430 != 0) goto <D.27431>; else goto <D.27432>;
      <D.27431>:
      D.27384 = 1;
      return D.27384;
      <D.27432>:
      <D.27429>:
      D.27421 = candidate->interfaces;
      D.27422 = (long unsigned int) i;
      D.27423 = D.27422 * 8;
      D.27424 = D.27421 + D.27423;
      D.27425 = *D.27424;
      D.27433 = mono_class_implement_interface_slow (target, D.27425);
      if (D.27433 != 0) goto <D.27434>; else goto <D.27435>;
      <D.27434>:
      D.27384 = 1;
      return D.27384;
      <D.27435>:
      i = i + 1;
      <D.20813>:
      D.27436 = candidate->interface_count;
      D.27437 = (int) D.27436;
      if (D.27437 > i) goto <D.20812>; else goto <D.20814>;
      <D.20814>:
      candidate = candidate->parent;
      if (candidate != 0B) goto <D.20815>; else goto <D.20816>;
      <D.20816>:
      D.27384 = 0;
      return D.27384;
    }
  finally
    {
      error = {CLOBBER};
    }
}


mono_class_is_variant_compatible_slow (struct MonoClass * klass, struct MonoClass * oklass)
{
  struct MonoClass * D.27442;
  gboolean D.27444;
  struct MonoGenericClass * D.27445;
  struct MonoGenericInst * D.27446;
  struct MonoGenericClass * D.27447;
  struct MonoGenericInst * D.27448;
  long unsigned int D.27449;
  long unsigned int D.27450;
  struct MonoType * * D.27451;
  struct MonoType * D.27452;
  struct MonoType * * D.27453;
  struct MonoType * D.27454;
  long unsigned int D.27455;
  long unsigned int D.27456;
  long unsigned int D.27457;
  long unsigned int D.27458;
  struct MonoGenericParamFull * D.27463;
  long unsigned int D.27464;
  struct MonoGenericParamFull * D.27465;
  short unsigned int D.27466;
  int D.27467;
  int D.27468;
  int D.27471;
  int D.27475;
  int D.27478;
  <unnamed-signed:31> D.27482;
  int D.27483;
  int j;
  struct MonoType * * klass_argv;
  struct MonoType * * oklass_argv;
  struct MonoClass * klass_gtd;
  struct MonoGenericContainer * container;

  klass_gtd = mono_class_get_generic_type_definition (klass);
  container = klass_gtd->generic_container;
  D.27442 = mono_class_get_generic_type_definition (oklass);
  if (D.27442 != klass_gtd) goto <D.27440>; else goto <D.27443>;
  <D.27443>:
  if (oklass == klass_gtd) goto <D.27440>; else goto <D.27441>;
  <D.27440>:
  D.27444 = 0;
  return D.27444;
  <D.27441>:
  D.27445 = klass->generic_class;
  D.27446 = D.27445->context.class_inst;
  klass_argv = &D.27446->type_argv[0];
  D.27447 = oklass->generic_class;
  D.27448 = D.27447->context.class_inst;
  oklass_argv = &D.27448->type_argv[0];
  j = 0;
  goto <D.20795>;
  <D.20794>:
  {
    struct MonoClass * param1_class;
    struct MonoClass * param2_class;

    D.27449 = (long unsigned int) j;
    D.27450 = D.27449 * 8;
    D.27451 = klass_argv + D.27450;
    D.27452 = *D.27451;
    param1_class = mono_class_from_mono_type (D.27452);
    D.27449 = (long unsigned int) j;
    D.27450 = D.27449 * 8;
    D.27453 = oklass_argv + D.27450;
    D.27454 = *D.27453;
    param2_class = mono_class_from_mono_type (D.27454);
    D.27455 = BIT_FIELD_REF <*param1_class, 64, 256>;
    D.27456 = BIT_FIELD_REF <*param2_class, 64, 256>;
    D.27457 = D.27455 ^ D.27456;
    D.27458 = D.27457 & 1152921504606846976;
    if (D.27458 != 0) goto <D.27459>; else goto <D.27460>;
    <D.27459>:
    D.27444 = 0;
    return D.27444;
    <D.27460>:
    if (param1_class != param2_class) goto <D.27461>; else goto <D.27462>;
    <D.27461>:
    D.27463 = container->type_params;
    D.27449 = (long unsigned int) j;
    D.27464 = D.27449 * 56;
    D.27465 = D.27463 + D.27464;
    D.27466 = D.27465->info.flags;
    D.27467 = (int) D.27466;
    D.27468 = D.27467 & 1;
    if (D.27468 != 0) goto <D.27469>; else goto <D.27470>;
    <D.27469>:
    D.27471 = mono_class_is_assignable_from_slow (param1_class, param2_class);
    if (D.27471 == 0) goto <D.27472>; else goto <D.27473>;
    <D.27472>:
    D.27444 = 0;
    return D.27444;
    <D.27473>:
    goto <D.27474>;
    <D.27470>:
    D.27463 = container->type_params;
    D.27449 = (long unsigned int) j;
    D.27464 = D.27449 * 56;
    D.27465 = D.27463 + D.27464;
    D.27466 = D.27465->info.flags;
    D.27467 = (int) D.27466;
    D.27475 = D.27467 & 2;
    if (D.27475 != 0) goto <D.27476>; else goto <D.27477>;
    <D.27476>:
    D.27478 = mono_class_is_assignable_from_slow (param2_class, param1_class);
    if (D.27478 == 0) goto <D.27479>; else goto <D.27480>;
    <D.27479>:
    D.27444 = 0;
    return D.27444;
    <D.27480>:
    goto <D.27481>;
    <D.27477>:
    D.27444 = 0;
    return D.27444;
    <D.27481>:
    <D.27474>:
    <D.27462>:
  }
  j = j + 1;
  <D.20795>:
  D.27482 = container->type_argc;
  D.27483 = (int) D.27482;
  if (D.27483 > j) goto <D.20794>; else goto <D.20796>;
  <D.20796>:
  D.27444 = 1;
  return D.27444;
}


__attribute__((visibility ("hidden")))
mono_class_get_cctor (struct MonoClass * klass)
{
  struct MonoImage * D.27485;
  long unsigned int D.27486;
  long unsigned int D.27487;
  struct MonoMethod * D.27490;
  long unsigned int D.27491;
  long unsigned int D.27492;
  int D.27495;
  unsigned int D.27498;
  struct MonoGenericClass * D.27499;
  struct MonoMethod * * D.27502;
  struct MonoClass * D.27505;
  struct MonoMethod * D.27506;
  struct MonoCachedClassInfo cached_info;

  try
    {
      D.27485 = klass->image;
      D.27486 = BIT_FIELD_REF <*D.27485, 64, 192>;
      D.27487 = D.27486 & 268435456;
      if (D.27487 != 0) goto <D.27488>; else goto <D.27489>;
      <D.27488>:
      D.27490 = mono_class_get_method_from_name_flags (klass, ".cctor", -1, 2048);
      return D.27490;
      <D.27489>:
      D.27491 = BIT_FIELD_REF <*klass, 64, 256>;
      D.27492 = D.27491 & 137438953472;
      if (D.27492 == 0) goto <D.27493>; else goto <D.27494>;
      <D.27493>:
      D.27490 = 0B;
      return D.27490;
      <D.27494>:
      D.27495 = mono_class_get_cached_class_info (klass, &cached_info);
      if (D.27495 != 0) goto <D.27496>; else goto <D.27497>;
      <D.27496>:
      D.27485 = klass->image;
      D.27498 = cached_info.cctor_token;
      D.27490 = mono_get_method (D.27485, D.27498, klass);
      return D.27490;
      <D.27497>:
      D.27499 = klass->generic_class;
      if (D.27499 != 0B) goto <D.27500>; else goto <D.27501>;
      <D.27500>:
      D.27502 = klass->methods;
      if (D.27502 == 0B) goto <D.27503>; else goto <D.27504>;
      <D.27503>:
      D.27499 = klass->generic_class;
      D.27505 = D.27499->container_class;
      D.27506 = mono_class_get_cctor (D.27505);
      D.27490 = mono_class_get_inflated_method (klass, D.27506);
      return D.27490;
      <D.27504>:
      <D.27501>:
      D.27490 = mono_class_get_method_from_name_flags (klass, ".cctor", -1, 2048);
      return D.27490;
    }
  finally
    {
      cached_info = {CLOBBER};
    }
}


__attribute__((visibility ("hidden")))
mono_class_get_finalizer (struct MonoClass * klass)
{
  long unsigned int D.27509;
  long unsigned int D.27510;
  int D.27513;
  struct MonoMethod * D.27516;
  int D.27517;
  struct MonoImage * D.27520;
  unsigned int D.27521;
  struct MonoMethod * * D.27522;
  int finalize_slot.246;
  long unsigned int D.27524;
  long unsigned int D.27525;
  struct MonoMethod * * D.27526;
  struct MonoCachedClassInfo cached_info;

  try
    {
      D.27509 = BIT_FIELD_REF <*klass, 64, 256>;
      D.27510 = D.27509 & 9223372036854775808;
      if (D.27510 == 0) goto <D.27511>; else goto <D.27512>;
      <D.27511>:
      mono_class_init (klass);
      <D.27512>:
      D.27513 = mono_class_has_finalizer (klass);
      if (D.27513 == 0) goto <D.27514>; else goto <D.27515>;
      <D.27514>:
      D.27516 = 0B;
      return D.27516;
      <D.27515>:
      D.27517 = mono_class_get_cached_class_info (klass, &cached_info);
      if (D.27517 != 0) goto <D.27518>; else goto <D.27519>;
      <D.27518>:
      D.27520 = cached_info.finalize_image;
      D.27521 = cached_info.finalize_token;
      D.27516 = mono_get_method (D.27520, D.27521, 0B);
      return D.27516;
      <D.27519>:
      mono_class_setup_vtable (klass);
      D.27522 = klass->vtable;
      finalize_slot.246 = finalize_slot;
      D.27524 = (long unsigned int) finalize_slot.246;
      D.27525 = D.27524 * 8;
      D.27526 = D.27522 + D.27525;
      D.27516 = *D.27526;
      return D.27516;
    }
  finally
    {
      cached_info = {CLOBBER};
    }
}


__attribute__((visibility ("hidden")))
mono_class_needs_cctor_run (struct MonoClass * klass, struct MonoMethod * caller)
{
  gboolean D.27531;
  _Bool D.27532;
  struct MonoMethod * method;

  method = mono_class_get_cctor (klass);
  if (method != 0B) goto <D.27529>; else goto <D.27530>;
  <D.27529>:
  D.27532 = method != caller;
  D.27531 = (gboolean) D.27532;
  return D.27531;
  <D.27530>:
  D.27531 = 0;
  return D.27531;
}


mono_class_array_element_size (struct MonoClass * klass)
{
  unsigned char D.27534;
  int D.27535;
  int32_t D.27536;
  struct MonoClass * D.27537;
  long unsigned int D.27538;
  long unsigned int D.27539;
  int D.27542;
  unsigned int D.27543;
  unsigned int D.27544;
  struct MonoGenericClass * D.27545;
  struct MonoClass * D.27546;
  struct MonoType * type;
  void handle_enum = <<< error >>>;

  type = &klass->byval_arg;
  handle_enum:
  D.27534 = type->type;
  D.27535 = (int) D.27534;
  switch (D.27535) <default: <D.20866>, case 1: <D.20865>, case 2: <D.20843>, case 3: <D.20846>, case 4: <D.20841>, case 5: <D.20842>, case 6: <D.20844>, case 7: <D.20845>, case 8: <D.20847>, case 9: <D.20848>, case 10: <D.20860>, case 11: <D.20861>, case 12: <D.20849>, case 13: <D.20862>, case 14: <D.20854>, case 15: <D.20852>, case 17: <D.20863>, case 18: <D.20853>, case 19: <D.20858>, case 20: <D.20857>, case 21: <D.20864>, case 24: <D.20850>, case 25: <D.20851>, case 28: <D.20855>, case 29: <D.20856>, case 30: <D.20859>>
  <D.20841>:
  <D.20842>:
  <D.20843>:
  D.27536 = 1;
  return D.27536;
  <D.20844>:
  <D.20845>:
  <D.20846>:
  D.27536 = 2;
  return D.27536;
  <D.20847>:
  <D.20848>:
  <D.20849>:
  D.27536 = 4;
  return D.27536;
  <D.20850>:
  <D.20851>:
  <D.20852>:
  <D.20853>:
  <D.20854>:
  <D.20855>:
  <D.20856>:
  <D.20857>:
  <D.20858>:
  <D.20859>:
  D.27536 = 8;
  return D.27536;
  <D.20860>:
  <D.20861>:
  <D.20862>:
  D.27536 = 8;
  return D.27536;
  <D.20863>:
  D.27537 = type->data.klass;
  D.27538 = BIT_FIELD_REF <*D.27537, 64, 256>;
  D.27539 = D.27538 & 576460752303423488;
  if (D.27539 != 0) goto <D.27540>; else goto <D.27541>;
  <D.27540>:
  D.27537 = type->data.klass;
  type = mono_class_enum_basetype (D.27537);
  klass = klass->element_class;
  goto handle_enum;
  <D.27541>:
  D.27542 = mono_class_instance_size (klass);
  D.27543 = (unsigned int) D.27542;
  D.27544 = D.27543 + 4294967280;
  D.27536 = (int32_t) D.27544;
  return D.27536;
  <D.20864>:
  D.27545 = type->data.generic_class;
  D.27546 = D.27545->container_class;
  type = &D.27546->byval_arg;
  goto handle_enum;
  <D.20865>:
  D.27536 = 0;
  return D.27536;
  <D.20866>:
  D.27534 = type->type;
  D.27535 = (int) D.27534;
  monoeg_g_log (0B, 4, "unknown type 0x%02x in mono_class_array_element_size", D.27535);
  <D.20867>:
  goto <D.20867>;
  D.27536 = -1;
  return D.27536;
}


mono_array_element_size (struct MonoClass * ac)
{
  unsigned char D.27548;
  _Bool D.27549;
  long int D.27550;
  long int D.27551;
  int32_t D.27554;

  D.27548 = ac->rank;
  D.27549 = D.27548 == 0;
  D.27550 = (long int) D.27549;
  D.27551 = __builtin_expect (D.27550, 0);
  if (D.27551 != 0) goto <D.27552>; else goto <D.27553>;
  <D.27552>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "class.c", 8238, "ac->rank");
  <D.27553>:
  D.27554 = ac->sizes.element_size;
  return D.27554;
}


mono_ldtoken (struct MonoImage * image, guint32 token, struct MonoClass * * handle_class, struct MonoGenericContext * context)
{
  long unsigned int D.27556;
  long unsigned int D.27557;
  struct MonoClass * tmp_handle_class.247;
  _Bool D.27561;
  long int D.27562;
  long int D.27563;
  struct MonoClass * D.27568;
  void * D.27571;
  unsigned int D.27572;
  struct MonoClass * D.27577;
  unsigned int D.27578;
  struct MonoClass * D.27583;
  unsigned int D.27584;
  struct MonoClass * D.27589;
  struct MonoTableInfo * D.27590;
  unsigned int D.27591;
  int D.27592;
  unsigned int D.27593;
  const char * sig.248;
  const char * sig.249;
  char D.27596;

  D.27556 = BIT_FIELD_REF <*image, 64, 192>;
  D.27557 = D.27556 & 268435456;
  if (D.27557 != 0) goto <D.27558>; else goto <D.27559>;
  <D.27558>:
  {
    struct MonoClass * tmp_handle_class;
    void * obj;

    try
      {
        obj = mono_lookup_dynamic_token_class (image, token, 1, &tmp_handle_class, context);
        tmp_handle_class.247 = tmp_handle_class;
        D.27561 = tmp_handle_class.247 == 0B;
        D.27562 = (long int) D.27561;
        D.27563 = __builtin_expect (D.27562, 0);
        if (D.27563 != 0) goto <D.27564>; else goto <D.27565>;
        <D.27564>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "class.c", 8250, "tmp_handle_class");
        <D.27565>:
        if (handle_class != 0B) goto <D.27566>; else goto <D.27567>;
        <D.27566>:
        tmp_handle_class.247 = tmp_handle_class;
        *handle_class = tmp_handle_class.247;
        <D.27567>:
        D.27568 = mono_defaults.typehandle_class;
        tmp_handle_class.247 = tmp_handle_class;
        if (D.27568 == tmp_handle_class.247) goto <D.27569>; else goto <D.27570>;
        <D.27569>:
        D.27571 = &MEM[(struct MonoClass *)obj].byval_arg;
        return D.27571;
        <D.27570>:
        D.27571 = obj;
        return D.27571;
      }
    finally
      {
        tmp_handle_class = {CLOBBER};
      }
  }
  <D.27559>:
  D.27572 = token & 4278190080;
  switch (D.27572) <default: <D.20895>, case 16777216: <D.20880>, case 33554432: <D.20879>, case 67108864: <D.20883>, case 100663296: <D.20886>, case 167772160: <D.20889>, case 452984832: <D.20881>, case 721420288: <D.20887>>
  <D.20879>:
  <D.20880>:
  <D.20881>:
  {
    struct MonoType * type;

    if (handle_class != 0B) goto <D.27573>; else goto <D.27574>;
    <D.27573>:
    D.27568 = mono_defaults.typehandle_class;
    *handle_class = D.27568;
    <D.27574>:
    type = mono_type_get_full (image, token, context);
    if (type == 0B) goto <D.27575>; else goto <D.27576>;
    <D.27575>:
    D.27571 = 0B;
    return D.27571;
    <D.27576>:
    D.27577 = mono_class_from_mono_type (type);
    mono_class_init (D.27577);
    D.27571 = type;
    return D.27571;
  }
  <D.20883>:
  {
    struct MonoClass * class;
    guint32 type;

    D.27578 = token & 16777215;
    type = mono_metadata_typedef_from_field (image, D.27578);
    if (type == 0) goto <D.27579>; else goto <D.27580>;
    <D.27579>:
    D.27571 = 0B;
    return D.27571;
    <D.27580>:
    if (handle_class != 0B) goto <D.27581>; else goto <D.27582>;
    <D.27581>:
    D.27583 = mono_defaults.fieldhandle_class;
    *handle_class = D.27583;
    <D.27582>:
    D.27584 = type | 33554432;
    class = mono_class_get_full (image, D.27584, context);
    if (class == 0B) goto <D.27585>; else goto <D.27586>;
    <D.27585>:
    D.27571 = 0B;
    return D.27571;
    <D.27586>:
    mono_class_init (class);
    D.27571 = mono_class_get_field (class, token);
    return D.27571;
  }
  <D.20886>:
  <D.20887>:
  {
    struct MonoMethod * meth;

    meth = mono_get_method_full (image, token, 0B, context);
    if (handle_class != 0B) goto <D.27587>; else goto <D.27588>;
    <D.27587>:
    D.27589 = mono_defaults.methodhandle_class;
    *handle_class = D.27589;
    <D.27588>:
    D.27571 = meth;
    return D.27571;
  }
  <D.20889>:
  {
    guint32 cols[3];
    const char * sig;

    try
      {
        D.27590 = &image->tables[10];
        D.27578 = token & 16777215;
        D.27591 = D.27578 + 4294967295;
        D.27592 = (int) D.27591;
        mono_metadata_decode_row (D.27590, D.27592, &cols, 3);
        D.27593 = cols[2];
        sig.248 = mono_metadata_blob_heap (image, D.27593);
        sig = sig.248;
        sig.249 = sig;
        mono_metadata_decode_blob_size (sig.249, &sig);
        sig.249 = sig;
        D.27596 = *sig.249;
        if (D.27596 == 6) goto <D.27597>; else goto <D.27598>;
        <D.27597>:
        {
          struct MonoClass * klass;
          struct MonoClassField * field;

          try
            {
              field = mono_field_from_token (image, token, &klass, context);
              if (handle_class != 0B) goto <D.27599>; else goto <D.27600>;
              <D.27599>:
              D.27583 = mono_defaults.fieldhandle_class;
              *handle_class = D.27583;
              <D.27600>:
              D.27571 = field;
              return D.27571;
            }
          finally
            {
              klass = {CLOBBER};
            }
        }
        <D.27598>:
        {
          struct MonoMethod * meth;

          meth = mono_get_method_full (image, token, 0B, context);
          if (handle_class != 0B) goto <D.27601>; else goto <D.27602>;
          <D.27601>:
          D.27589 = mono_defaults.methodhandle_class;
          *handle_class = D.27589;
          <D.27602>:
          D.27571 = meth;
          return D.27571;
        }
      }
    finally
      {
        cols = {CLOBBER};
        sig = {CLOBBER};
      }
  }
  <D.20895>:
  monoeg_g_log (0B, 16, "Unknown token 0x%08x in ldtoken", token);
  goto <D.20896>;
  <D.20896>:
  D.27571 = 0B;
  return D.27571;
}


__attribute__((visibility ("hidden")))
mono_install_lookup_dynamic_token (void * (*MonoLookupDynamicToken) (struct MonoImage *, guint32, gboolean, struct MonoClass * *, struct MonoGenericContext *) func)
{
  lookup_dynamic = func;
}


__attribute__((visibility ("hidden")))
mono_lookup_dynamic_token (struct MonoImage * image, guint32 token, struct MonoGenericContext * context)
{
  void * D.27607;
  void * (*<T1fdb>) (struct MonoImage *, guint32, gboolean, struct MonoClass * *, struct MonoGenericContext *) lookup_dynamic.250;
  struct MonoClass * handle_class;

  try
    {
      lookup_dynamic.250 = lookup_dynamic;
      D.27607 = lookup_dynamic.250 (image, token, 1, &handle_class, context);
      return D.27607;
    }
  finally
    {
      handle_class = {CLOBBER};
    }
}


__attribute__((visibility ("hidden")))
mono_lookup_dynamic_token_class (struct MonoImage * image, guint32 token, gboolean valid_token, struct MonoClass * * handle_class, struct MonoGenericContext * context)
{
  void * D.27611;
  void * (*<T1fdb>) (struct MonoImage *, guint32, gboolean, struct MonoClass * *, struct MonoGenericContext *) lookup_dynamic.251;

  lookup_dynamic.251 = lookup_dynamic;
  D.27611 = lookup_dynamic.251 (image, token, valid_token, handle_class, context);
  return D.27611;
}


__attribute__((visibility ("hidden")))
mono_install_get_cached_class_info (gboolean (*MonoGetCachedClassInfo) (struct MonoClass *, struct MonoCachedClassInfo *) func)
{
  get_cached_class_info = func;
}


__attribute__((visibility ("hidden")))
mono_install_get_class_from_name (gboolean (*MonoGetClassFromName) (struct MonoImage *, const char *, const char *, struct MonoClass * *) func)
{
  get_class_from_name = func;
}


mono_class_get_image (struct MonoClass * klass)
{
  struct MonoImage * D.27614;

  D.27614 = klass->image;
  return D.27614;
}


mono_class_get_element_class (struct MonoClass * klass)
{
  struct MonoClass * D.27616;

  D.27616 = klass->element_class;
  return D.27616;
}


mono_class_is_valuetype (struct MonoClass * klass)
{
  mono_bool D.27618;
  <unnamed-unsigned:1> D.27619;

  D.27619 = klass->valuetype;
  D.27618 = (mono_bool) D.27619;
  return D.27618;
}


mono_class_is_enum (struct MonoClass * klass)
{
  mono_bool D.27621;
  <unnamed-unsigned:1> D.27622;

  D.27622 = klass->enumtype;
  D.27621 = (mono_bool) D.27622;
  return D.27621;
}


mono_class_enum_basetype (struct MonoClass * klass)
{
  struct MonoClass * D.27624;
  struct MonoType * D.27627;

  D.27624 = klass->element_class;
  if (D.27624 == klass) goto <D.27625>; else goto <D.27626>;
  <D.27625>:
  D.27627 = 0B;
  return D.27627;
  <D.27626>:
  D.27624 = klass->element_class;
  D.27627 = &D.27624->byval_arg;
  return D.27627;
}


mono_class_get_parent (struct MonoClass * klass)
{
  struct MonoClass * D.27629;

  D.27629 = klass->parent;
  return D.27629;
}


mono_class_get_nesting_type (struct MonoClass * klass)
{
  struct MonoClass * D.27631;

  D.27631 = klass->nested_in;
  return D.27631;
}


mono_class_get_rank (struct MonoClass * klass)
{
  int D.27633;
  unsigned char D.27634;

  D.27634 = klass->rank;
  D.27633 = (int) D.27634;
  return D.27633;
}


mono_class_get_flags (struct MonoClass * klass)
{
  uint32_t D.27636;

  D.27636 = klass->flags;
  return D.27636;
}


mono_class_get_name (struct MonoClass * klass)
{
  const char * D.27638;

  D.27638 = klass->name;
  return D.27638;
}


mono_class_get_namespace (struct MonoClass * klass)
{
  const char * D.27640;

  D.27640 = klass->name_space;
  return D.27640;
}


mono_class_get_type (struct MonoClass * klass)
{
  struct MonoType * D.27642;

  D.27642 = &klass->byval_arg;
  return D.27642;
}


mono_class_get_type_token (struct MonoClass * klass)
{
  uint32_t D.27644;

  D.27644 = klass->type_token;
  return D.27644;
}


mono_class_get_byref_type (struct MonoClass * klass)
{
  struct MonoType * D.27646;

  D.27646 = &klass->this_arg;
  return D.27646;
}


mono_class_num_fields (struct MonoClass * klass)
{
  int D.27648;
  unsigned int D.27649;

  D.27649 = klass->field.count;
  D.27648 = (int) D.27649;
  return D.27648;
}


mono_class_num_methods (struct MonoClass * klass)
{
  int D.27651;
  unsigned int D.27652;

  D.27652 = klass->method.count;
  D.27651 = (int) D.27652;
  return D.27651;
}


mono_class_num_properties (struct MonoClass * klass)
{
  int D.27654;
  struct MonoClassExt * D.27655;
  unsigned int D.27656;

  mono_class_setup_properties (klass);
  D.27655 = klass->ext;
  D.27656 = D.27655->property.count;
  D.27654 = (int) D.27656;
  return D.27654;
}


mono_class_setup_properties (struct MonoClass * class)
{
  struct MonoImage * D.27658;
  struct MonoClassExt * D.27659;
  struct MonoProperty * D.27662;
  struct MonoGenericClass * D.27669;
  unsigned char D.27672;
  gchar * D.27675;
  struct MonoClassExt * D.27676;
  unsigned int D.27677;
  unsigned int D.27678;
  unsigned int D.27679;
  int D.27680;
  long unsigned int D.27681;
  long unsigned int D.27682;
  struct MonoProperty * D.27683;
  struct MonoProperty * D.27684;
  struct MonoMethod * D.27685;
  struct MonoGenericContext * D.27688;
  struct MonoMethod * D.27689;
  struct MonoMethod * D.27690;
  struct MonoGenericContext * D.27693;
  struct MonoMethod * D.27694;
  unsigned int D.27696;
  unsigned int D.27697;
  unsigned int D.27698;
  unsigned int D.27699;
  unsigned int last.252;
  unsigned int first.253;
  unsigned int D.27702;
  unsigned char D.27705;
  unsigned int count.254;
  unsigned int count.255;
  unsigned int D.27710;
  int D.27711;
  int i.256;
  unsigned int first.257;
  unsigned int D.27714;
  long unsigned int D.27715;
  long unsigned int D.27716;
  struct MonoProperty * D.27717;
  unsigned int D.27718;
  unsigned int D.27719;
  const char * D.27720;
  int j.258;
  long unsigned int D.27722;
  long unsigned int D.27723;
  unsigned int D.27726;
  struct MonoMethod * * D.27728;
  unsigned int D.27729;
  unsigned int D.27730;
  unsigned int D.27731;
  long unsigned int D.27732;
  long unsigned int D.27733;
  struct MonoMethod * * D.27734;
  unsigned int endm.259;
  guint startm;
  guint endm;
  guint i;
  guint j;
  guint32 cols[3];
  struct MonoTableInfo * msemt;
  struct MonoProperty * properties;
  guint32 last;

  try
    {
      D.27658 = class->image;
      msemt = &D.27658->tables[24];
      D.27659 = class->ext;
      if (D.27659 != 0B) goto <D.27660>; else goto <D.27661>;
      <D.27660>:
      D.27659 = class->ext;
      D.27662 = D.27659->properties;
      if (D.27662 != 0B) goto <D.27663>; else goto <D.27664>;
      <D.27663>:
      return;
      <D.27664>:
      <D.27661>:
      mono_loader_lock ();
      D.27659 = class->ext;
      if (D.27659 != 0B) goto <D.27665>; else goto <D.27666>;
      <D.27665>:
      D.27659 = class->ext;
      D.27662 = D.27659->properties;
      if (D.27662 != 0B) goto <D.27667>; else goto <D.27668>;
      <D.27667>:
      mono_loader_unlock ();
      return;
      <D.27668>:
      <D.27666>:
      mono_class_alloc_ext (class);
      D.27669 = class->generic_class;
      if (D.27669 != 0B) goto <D.27670>; else goto <D.27671>;
      <D.27670>:
      {
        struct MonoClass * gklass;

        D.27669 = class->generic_class;
        gklass = D.27669->container_class;
        mono_class_init (gklass);
        mono_class_setup_properties (gklass);
        D.27672 = gklass->exception_type;
        if (D.27672 != 0) goto <D.27673>; else goto <D.27674>;
        <D.27673>:
        D.27675 = monoeg_strdup ("Generic type definition failed to load");
        mono_class_set_failure (class, 7, D.27675);
        mono_loader_unlock ();
        return;
        <D.27674>:
        D.27659 = class->ext;
        D.27676 = gklass->ext;
        D.27659->property = D.27676->property;
        D.27659 = class->ext;
        D.27677 = D.27659->property.count;
        D.27678 = D.27677 + 1;
        D.27679 = D.27678 * 40;
        D.27680 = (int) D.27679;
        properties = mono_class_alloc0 (class, D.27680);
        i = 0;
        goto <D.19458>;
        <D.19457>:
        {
          struct MonoProperty * prop;

          D.27681 = (long unsigned int) i;
          D.27682 = D.27681 * 40;
          prop = properties + D.27682;
          D.27676 = gklass->ext;
          D.27683 = D.27676->properties;
          D.27681 = (long unsigned int) i;
          D.27682 = D.27681 * 40;
          D.27684 = D.27683 + D.27682;
          *prop = *D.27684;
          D.27685 = prop->get;
          if (D.27685 != 0B) goto <D.27686>; else goto <D.27687>;
          <D.27686>:
          D.27685 = prop->get;
          D.27688 = mono_class_get_context (class);
          D.27689 = mono_class_inflate_generic_method_full (D.27685, class, D.27688);
          prop->get = D.27689;
          <D.27687>:
          D.27690 = prop->set;
          if (D.27690 != 0B) goto <D.27691>; else goto <D.27692>;
          <D.27691>:
          D.27690 = prop->set;
          D.27693 = mono_class_get_context (class);
          D.27694 = mono_class_inflate_generic_method_full (D.27690, class, D.27693);
          prop->set = D.27694;
          <D.27692>:
          prop->parent = class;
        }
        i = i + 1;
        <D.19458>:
        D.27659 = class->ext;
        D.27677 = D.27659->property.count;
        if (D.27677 > i) goto <D.19457>; else goto <D.19459>;
        <D.19459>:
      }
      goto <D.27695>;
      <D.27671>:
      {
        int first;
        int count;

        D.27658 = class->image;
        D.27696 = class->type_token;
        D.27697 = D.27696 & 16777215;
        D.27698 = D.27697 + 4294967295;
        D.27699 = mono_metadata_properties_from_typedef (D.27658, D.27698, &last);
        first = (int) D.27699;
        last.252 = last;
        first.253 = (unsigned int) first;
        D.27702 = last.252 - first.253;
        count = (int) D.27702;
        if (count != 0) goto <D.27703>; else goto <D.27704>;
        <D.27703>:
        mono_class_setup_methods (class);
        D.27705 = class->exception_type;
        if (D.27705 != 0) goto <D.27706>; else goto <D.27707>;
        <D.27706>:
        mono_loader_unlock ();
        return;
        <D.27707>:
        <D.27704>:
        D.27659 = class->ext;
        first.253 = (unsigned int) first;
        D.27659->property.first = first.253;
        D.27659 = class->ext;
        count.254 = (unsigned int) count;
        D.27659->property.count = count.254;
        count.255 = (unsigned int) count;
        D.27710 = count.255 * 40;
        D.27711 = (int) D.27710;
        properties = mono_class_alloc0 (class, D.27711);
        i = (guint) first;
        goto <D.19471>;
        <D.19470>:
        D.27658 = class->image;
        i.256 = (int) i;
        mono_metadata_decode_table_row (D.27658, 23, i.256, &cols, 3);
        first.257 = (unsigned int) first;
        D.27714 = i - first.257;
        D.27715 = (long unsigned int) D.27714;
        D.27716 = D.27715 * 40;
        D.27717 = properties + D.27716;
        D.27717->parent = class;
        first.257 = (unsigned int) first;
        D.27714 = i - first.257;
        D.27715 = (long unsigned int) D.27714;
        D.27716 = D.27715 * 40;
        D.27717 = properties + D.27716;
        D.27718 = cols[0];
        D.27717->attrs = D.27718;
        first.257 = (unsigned int) first;
        D.27714 = i - first.257;
        D.27715 = (long unsigned int) D.27714;
        D.27716 = D.27715 * 40;
        D.27717 = properties + D.27716;
        D.27658 = class->image;
        D.27719 = cols[1];
        D.27720 = mono_metadata_string_heap (D.27658, D.27719);
        D.27717->name = D.27720;
        D.27658 = class->image;
        startm = mono_metadata_methods_from_property (D.27658, i, &endm);
        j = startm;
        goto <D.19468>;
        <D.19467>:
        {
          struct MonoMethod * method;

          j.258 = (int) j;
          mono_metadata_decode_row (msemt, j.258, &cols, 3);
          D.27658 = class->image;
          D.27722 = BIT_FIELD_REF <*D.27658, 64, 192>;
          D.27723 = D.27722 & 67108864;
          if (D.27723 != 0) goto <D.27724>; else goto <D.27725>;
          <D.27724>:
          D.27658 = class->image;
          D.27719 = cols[1];
          D.27726 = D.27719 | 100663296;
          method = mono_get_method (D.27658, D.27726, class);
          goto <D.27727>;
          <D.27725>:
          D.27728 = class->methods;
          D.27719 = cols[1];
          D.27729 = class->method.first;
          D.27730 = D.27719 - D.27729;
          D.27731 = D.27730 + 4294967295;
          D.27732 = (long unsigned int) D.27731;
          D.27733 = D.27732 * 8;
          D.27734 = D.27728 + D.27733;
          method = *D.27734;
          <D.27727>:
          D.27718 = cols[0];
          switch (D.27718) <default: <D.19466>, case 1: <D.19463>, case 2: <D.19465>>
          <D.19463>:
          first.257 = (unsigned int) first;
          D.27714 = i - first.257;
          D.27715 = (long unsigned int) D.27714;
          D.27716 = D.27715 * 40;
          D.27717 = properties + D.27716;
          D.27717->set = method;
          goto <D.19464>;
          <D.19465>:
          first.257 = (unsigned int) first;
          D.27714 = i - first.257;
          D.27715 = (long unsigned int) D.27714;
          D.27716 = D.27715 * 40;
          D.27717 = properties + D.27716;
          D.27717->get = method;
          goto <D.19464>;
          <D.19466>:
          goto <D.19464>;
          <D.19464>:
        }
        j = j + 1;
        <D.19468>:
        endm.259 = endm;
        if (j < endm.259) goto <D.19467>; else goto <D.19469>;
        <D.19469>:
        i = i + 1;
        <D.19471>:
        last.252 = last;
        if (i < last.252) goto <D.19470>; else goto <D.19472>;
        <D.19472>:
      }
      <D.27695>:
      mono_memory_barrier ();
      D.27659 = class->ext;
      D.27659->properties = properties;
      mono_loader_unlock ();
    }
  finally
    {
      endm = {CLOBBER};
      cols = {CLOBBER};
      last = {CLOBBER};
    }
}


mono_class_num_events (struct MonoClass * klass)
{
  int D.27740;
  struct MonoClassExt * D.27741;
  unsigned int D.27742;

  mono_class_setup_events (klass);
  D.27741 = klass->ext;
  D.27742 = D.27741->event.count;
  D.27740 = (int) D.27742;
  return D.27740;
}


mono_class_setup_events (struct MonoClass * class)
{
  struct MonoImage * D.27744;
  struct MonoClassExt * D.27745;
  struct MonoEvent * D.27748;
  struct MonoGenericClass * D.27755;
  unsigned char D.27758;
  gchar * D.27761;
  struct MonoClassExt * D.27762;
  unsigned int D.27763;
  unsigned int D.27764;
  int D.27765;
  void * D.27766;
  long unsigned int D.27769;
  long unsigned int D.27770;
  struct MonoEvent * D.27771;
  const char * D.27772;
  struct MonoMethod * iftmp.260;
  struct MonoMethod * D.27774;
  struct MonoMethod * iftmp.261;
  struct MonoMethod * D.27779;
  struct MonoMethod * iftmp.262;
  struct MonoMethod * D.27784;
  struct MonoMethod * * iftmp.263;
  struct MonoMethod * * D.27789;
  unsigned int D.27793;
  unsigned int D.27794;
  unsigned int D.27795;
  unsigned int D.27796;
  unsigned int D.27797;
  unsigned int last.264;
  unsigned int first.265;
  unsigned int D.27800;
  unsigned char D.27803;
  gchar * D.27806;
  unsigned int count.266;
  unsigned int first.267;
  unsigned int D.27809;
  long unsigned int D.27810;
  long unsigned int D.27811;
  int i.268;
  unsigned int D.27813;
  unsigned int D.27814;
  const char * D.27815;
  int j.269;
  long unsigned int D.27817;
  long unsigned int D.27818;
  unsigned int D.27821;
  struct MonoMethod * * D.27823;
  unsigned int D.27824;
  unsigned int D.27825;
  unsigned int D.27826;
  long unsigned int D.27827;
  long unsigned int D.27828;
  struct MonoMethod * * D.27829;
  struct MonoMethod * * D.27830;
  void * D.27833;
  long unsigned int D.27835;
  long unsigned int D.27836;
  struct MonoMethod * * D.27837;
  struct MonoMethod * D.27838;
  int D.27839;
  long unsigned int D.27840;
  long unsigned int D.27841;
  void * D.27842;
  sizetype D.27843;
  sizetype D.27844;
  sizetype D.27845;
  struct MonoMethod * * D.27846;
  unsigned int endm.270;
  int first;
  int count;
  guint startm;
  guint endm;
  guint i;
  guint j;
  guint32 cols[3];
  struct MonoTableInfo * msemt;
  guint32 last;
  struct MonoEvent * events;

  try
    {
      D.27744 = class->image;
      msemt = &D.27744->tables[24];
      D.27745 = class->ext;
      if (D.27745 != 0B) goto <D.27746>; else goto <D.27747>;
      <D.27746>:
      D.27745 = class->ext;
      D.27748 = D.27745->events;
      if (D.27748 != 0B) goto <D.27749>; else goto <D.27750>;
      <D.27749>:
      return;
      <D.27750>:
      <D.27747>:
      mono_loader_lock ();
      D.27745 = class->ext;
      if (D.27745 != 0B) goto <D.27751>; else goto <D.27752>;
      <D.27751>:
      D.27745 = class->ext;
      D.27748 = D.27745->events;
      if (D.27748 != 0B) goto <D.27753>; else goto <D.27754>;
      <D.27753>:
      mono_loader_unlock ();
      return;
      <D.27754>:
      <D.27752>:
      mono_class_alloc_ext (class);
      D.27755 = class->generic_class;
      if (D.27755 != 0B) goto <D.27756>; else goto <D.27757>;
      <D.27756>:
      {
        struct MonoClass * gklass;
        struct MonoGenericContext * context;

        D.27755 = class->generic_class;
        gklass = D.27755->container_class;
        mono_class_setup_events (gklass);
        D.27758 = gklass->exception_type;
        if (D.27758 != 0) goto <D.27759>; else goto <D.27760>;
        <D.27759>:
        D.27761 = monoeg_strdup ("Generic type definition failed to load");
        mono_class_set_failure (class, 7, D.27761);
        mono_loader_unlock ();
        return;
        <D.27760>:
        D.27745 = class->ext;
        D.27762 = gklass->ext;
        D.27745->event = D.27762->event;
        D.27745 = class->ext;
        D.27745 = class->ext;
        D.27763 = D.27745->event.count;
        D.27764 = D.27763 * 56;
        D.27765 = (int) D.27764;
        D.27766 = mono_class_alloc0 (class, D.27765);
        D.27745->events = D.27766;
        D.27745 = class->ext;
        D.27763 = D.27745->event.count;
        if (D.27763 != 0) goto <D.27767>; else goto <D.27768>;
        <D.27767>:
        context = mono_class_get_context (class);
        <D.27768>:
        i = 0;
        goto <D.19505>;
        <D.19504>:
        {
          struct MonoEvent * event;
          struct MonoEvent * gevent;

          D.27745 = class->ext;
          D.27748 = D.27745->events;
          D.27769 = (long unsigned int) i;
          D.27770 = D.27769 * 56;
          event = D.27748 + D.27770;
          D.27762 = gklass->ext;
          D.27771 = D.27762->events;
          D.27769 = (long unsigned int) i;
          D.27770 = D.27769 * 56;
          gevent = D.27771 + D.27770;
          event->parent = class;
          D.27772 = gevent->name;
          event->name = D.27772;
          D.27774 = gevent->add;
          if (D.27774 != 0B) goto <D.27775>; else goto <D.27776>;
          <D.27775>:
          D.27774 = gevent->add;
          iftmp.260 = mono_class_inflate_generic_method_full (D.27774, class, context);
          goto <D.27777>;
          <D.27776>:
          iftmp.260 = 0B;
          <D.27777>:
          event->add = iftmp.260;
          D.27779 = gevent->remove;
          if (D.27779 != 0B) goto <D.27780>; else goto <D.27781>;
          <D.27780>:
          D.27779 = gevent->remove;
          iftmp.261 = mono_class_inflate_generic_method_full (D.27779, class, context);
          goto <D.27782>;
          <D.27781>:
          iftmp.261 = 0B;
          <D.27782>:
          event->remove = iftmp.261;
          D.27784 = gevent->raise;
          if (D.27784 != 0B) goto <D.27785>; else goto <D.27786>;
          <D.27785>:
          D.27784 = gevent->raise;
          iftmp.262 = mono_class_inflate_generic_method_full (D.27784, class, context);
          goto <D.27787>;
          <D.27786>:
          iftmp.262 = 0B;
          <D.27787>:
          event->raise = iftmp.262;
          D.27789 = gevent->other;
          if (D.27789 != 0B) goto <D.27790>; else goto <D.27791>;
          <D.27790>:
          D.27789 = gevent->other;
          iftmp.263 = inflate_method_listz (D.27789, class, context);
          goto <D.27792>;
          <D.27791>:
          iftmp.263 = 0B;
          <D.27792>:
          event->other = iftmp.263;
          D.27793 = gevent->attrs;
          event->attrs = D.27793;
        }
        i = i + 1;
        <D.19505>:
        D.27745 = class->ext;
        D.27763 = D.27745->event.count;
        if (D.27763 > i) goto <D.19504>; else goto <D.19506>;
        <D.19506>:
        mono_loader_unlock ();
        return;
      }
      <D.27757>:
      D.27744 = class->image;
      D.27794 = class->type_token;
      D.27795 = D.27794 & 16777215;
      D.27796 = D.27795 + 4294967295;
      D.27797 = mono_metadata_events_from_typedef (D.27744, D.27796, &last);
      first = (int) D.27797;
      last.264 = last;
      first.265 = (unsigned int) first;
      D.27800 = last.264 - first.265;
      count = (int) D.27800;
      if (count != 0) goto <D.27801>; else goto <D.27802>;
      <D.27801>:
      mono_class_setup_methods (class);
      D.27803 = class->exception_type;
      if (D.27803 != 0) goto <D.27804>; else goto <D.27805>;
      <D.27804>:
      D.27806 = monoeg_strdup ("Generic type definition failed to load");
      mono_class_set_failure (class, 7, D.27806);
      mono_loader_unlock ();
      return;
      <D.27805>:
      <D.27802>:
      D.27745 = class->ext;
      first.265 = (unsigned int) first;
      D.27745->event.first = first.265;
      D.27745 = class->ext;
      count.266 = (unsigned int) count;
      D.27745->event.count = count.266;
      D.27745 = class->ext;
      D.27763 = D.27745->event.count;
      D.27764 = D.27763 * 56;
      D.27765 = (int) D.27764;
      events = mono_class_alloc0 (class, D.27765);
      i = (guint) first;
      goto <D.19523>;
      <D.19522>:
      {
        struct MonoEvent * event;

        first.267 = (unsigned int) first;
        D.27809 = i - first.267;
        D.27810 = (long unsigned int) D.27809;
        D.27811 = D.27810 * 56;
        event = events + D.27811;
        D.27744 = class->image;
        i.268 = (int) i;
        mono_metadata_decode_table_row (D.27744, 20, i.268, &cols, 3);
        event->parent = class;
        D.27813 = cols[0];
        event->attrs = D.27813;
        D.27744 = class->image;
        D.27814 = cols[1];
        D.27815 = mono_metadata_string_heap (D.27744, D.27814);
        event->name = D.27815;
        D.27744 = class->image;
        startm = mono_metadata_methods_from_event (D.27744, i, &endm);
        j = startm;
        goto <D.19520>;
        <D.19519>:
        {
          struct MonoMethod * method;

          j.269 = (int) j;
          mono_metadata_decode_row (msemt, j.269, &cols, 3);
          D.27744 = class->image;
          D.27817 = BIT_FIELD_REF <*D.27744, 64, 192>;
          D.27818 = D.27817 & 67108864;
          if (D.27818 != 0) goto <D.27819>; else goto <D.27820>;
          <D.27819>:
          D.27744 = class->image;
          D.27814 = cols[1];
          D.27821 = D.27814 | 100663296;
          method = mono_get_method (D.27744, D.27821, class);
          goto <D.27822>;
          <D.27820>:
          D.27823 = class->methods;
          D.27814 = cols[1];
          D.27824 = class->method.first;
          D.27825 = D.27814 - D.27824;
          D.27826 = D.27825 + 4294967295;
          D.27827 = (long unsigned int) D.27826;
          D.27828 = D.27827 * 8;
          D.27829 = D.27823 + D.27828;
          method = *D.27829;
          <D.27822>:
          D.27813 = cols[0];
          switch (D.27813) <default: <D.19518>, case 4: <D.19513>, case 8: <D.19509>, case 16: <D.19511>, case 32: <D.19512>>
          <D.19509>:
          event->add = method;
          goto <D.19510>;
          <D.19511>:
          event->remove = method;
          goto <D.19510>;
          <D.19512>:
          event->raise = method;
          goto <D.19510>;
          <D.19513>:
          {
            int n;

            n = 0;
            D.27830 = event->other;
            if (D.27830 == 0B) goto <D.27831>; else goto <D.27832>;
            <D.27831>:
            D.27833 = monoeg_malloc0 (16);
            event->other = D.27833;
            goto <D.27834>;
            <D.27832>:
            goto <D.19516>;
            <D.19515>:
            n = n + 1;
            <D.19516>:
            D.27830 = event->other;
            D.27835 = (long unsigned int) n;
            D.27836 = D.27835 * 8;
            D.27837 = D.27830 + D.27836;
            D.27838 = *D.27837;
            if (D.27838 != 0B) goto <D.19515>; else goto <D.19517>;
            <D.19517>:
            D.27830 = event->other;
            D.27839 = n + 2;
            D.27840 = (long unsigned int) D.27839;
            D.27841 = D.27840 * 8;
            D.27842 = monoeg_realloc (D.27830, D.27841);
            event->other = D.27842;
            <D.27834>:
            D.27830 = event->other;
            D.27835 = (long unsigned int) n;
            D.27836 = D.27835 * 8;
            D.27837 = D.27830 + D.27836;
            *D.27837 = method;
            D.27830 = event->other;
            D.27843 = (sizetype) n;
            D.27844 = D.27843 + 1;
            D.27845 = D.27844 * 8;
            D.27846 = D.27830 + D.27845;
            *D.27846 = 0B;
            goto <D.19510>;
          }
          <D.19518>:
          goto <D.19510>;
          <D.19510>:
        }
        j = j + 1;
        <D.19520>:
        endm.270 = endm;
        if (j < endm.270) goto <D.19519>; else goto <D.19521>;
        <D.19521>:
      }
      i = i + 1;
      <D.19523>:
      last.264 = last;
      if (i < last.264) goto <D.19522>; else goto <D.19524>;
      <D.19524>:
      mono_memory_barrier ();
      D.27745 = class->ext;
      D.27745->events = events;
      mono_loader_unlock ();
    }
  finally
    {
      endm = {CLOBBER};
      cols = {CLOBBER};
      last = {CLOBBER};
    }
}


inflate_method_listz (struct MonoMethod * * methods, struct MonoClass * class, struct MonoGenericContext * context)
{
  struct MonoMethod * D.27852;
  int D.27853;
  long unsigned int D.27854;
  long unsigned int D.27855;
  long unsigned int D.27856;
  long unsigned int D.27857;
  struct MonoMethod * * D.27858;
  struct MonoMethod * D.27859;
  struct MonoMethod * * D.27860;
  struct MonoMethod * * om;
  struct MonoMethod * * retval;
  int count;

  om = methods;
  count = 0;
  goto <D.19482>;
  <D.19481>:
  om = om + 8;
  count = count + 1;
  <D.19482>:
  D.27852 = *om;
  if (D.27852 != 0B) goto <D.19481>; else goto <D.19483>;
  <D.19483>:
  D.27853 = count + 1;
  D.27854 = (long unsigned int) D.27853;
  D.27855 = D.27854 * 8;
  retval = monoeg_malloc0 (D.27855);
  count = 0;
  om = methods;
  count = 0;
  goto <D.19485>;
  <D.19484>:
  D.27856 = (long unsigned int) count;
  D.27857 = D.27856 * 8;
  D.27858 = retval + D.27857;
  D.27852 = *om;
  D.27859 = mono_class_inflate_generic_method_full (D.27852, class, context);
  *D.27858 = D.27859;
  om = om + 8;
  count = count + 1;
  <D.19485>:
  D.27852 = *om;
  if (D.27852 != 0B) goto <D.19484>; else goto <D.19486>;
  <D.19486>:
  D.27860 = retval;
  return D.27860;
}


mono_class_get_fields (struct MonoClass * klass, void * * iter)
{
  struct MonoClassField * D.27864;
  void * D.27865;
  unsigned char D.27868;
  unsigned int D.27871;
  struct MonoClassField * D.27874;
  long unsigned int D.27875;
  long unsigned int D.27876;
  struct MonoClassField * D.27877;
  struct MonoClassField * field;

  if (iter == 0B) goto <D.27862>; else goto <D.27863>;
  <D.27862>:
  D.27864 = 0B;
  return D.27864;
  <D.27863>:
  D.27865 = *iter;
  if (D.27865 == 0B) goto <D.27866>; else goto <D.27867>;
  <D.27866>:
  mono_class_setup_fields_locking (klass);
  D.27868 = klass->exception_type;
  if (D.27868 != 0) goto <D.27869>; else goto <D.27870>;
  <D.27869>:
  D.27864 = 0B;
  return D.27864;
  <D.27870>:
  D.27871 = klass->field.count;
  if (D.27871 != 0) goto <D.27872>; else goto <D.27873>;
  <D.27872>:
  D.27874 = klass->fields;
  *iter = D.27874;
  D.27864 = *iter;
  return D.27864;
  <D.27873>:
  D.27864 = 0B;
  return D.27864;
  <D.27867>:
  field = *iter;
  field = field + 32;
  D.27874 = klass->fields;
  D.27871 = klass->field.count;
  D.27875 = (long unsigned int) D.27871;
  D.27876 = D.27875 * 32;
  D.27877 = D.27874 + D.27876;
  if (D.27877 > field) goto <D.27878>; else goto <D.27879>;
  <D.27878>:
  *iter = field;
  D.27864 = *iter;
  return D.27864;
  <D.27879>:
  D.27864 = 0B;
  return D.27864;
}


mono_class_get_methods (struct MonoClass * klass, void * * iter)
{
  struct MonoMethod * D.27883;
  void * D.27884;
  struct MonoMethod * * D.27887;
  unsigned int D.27890;
  long unsigned int D.27893;
  long unsigned int D.27894;
  struct MonoMethod * * D.27895;
  struct MonoMethod * * method;

  if (iter == 0B) goto <D.27881>; else goto <D.27882>;
  <D.27881>:
  D.27883 = 0B;
  return D.27883;
  <D.27882>:
  D.27884 = *iter;
  if (D.27884 == 0B) goto <D.27885>; else goto <D.27886>;
  <D.27885>:
  mono_class_setup_methods (klass);
  D.27887 = klass->methods;
  if (D.27887 == 0B) goto <D.27888>; else goto <D.27889>;
  <D.27888>:
  D.27883 = 0B;
  return D.27883;
  <D.27889>:
  D.27890 = klass->method.count;
  if (D.27890 != 0) goto <D.27891>; else goto <D.27892>;
  <D.27891>:
  D.27887 = klass->methods;
  *iter = D.27887;
  D.27887 = klass->methods;
  D.27883 = *D.27887;
  return D.27883;
  <D.27892>:
  D.27883 = 0B;
  return D.27883;
  <D.27886>:
  method = *iter;
  method = method + 8;
  D.27887 = klass->methods;
  D.27890 = klass->method.count;
  D.27893 = (long unsigned int) D.27890;
  D.27894 = D.27893 * 8;
  D.27895 = D.27887 + D.27894;
  if (D.27895 > method) goto <D.27896>; else goto <D.27897>;
  <D.27896>:
  *iter = method;
  D.27883 = *method;
  return D.27883;
  <D.27897>:
  D.27883 = 0B;
  return D.27883;
}


mono_class_get_properties (struct MonoClass * klass, void * * iter)
{
  struct MonoProperty * D.27901;
  void * D.27902;
  struct MonoClassExt * D.27905;
  unsigned int D.27906;
  struct MonoProperty * D.27909;
  long unsigned int D.27910;
  long unsigned int D.27911;
  struct MonoProperty * D.27912;
  struct MonoProperty * property;

  if (iter == 0B) goto <D.27899>; else goto <D.27900>;
  <D.27899>:
  D.27901 = 0B;
  return D.27901;
  <D.27900>:
  D.27902 = *iter;
  if (D.27902 == 0B) goto <D.27903>; else goto <D.27904>;
  <D.27903>:
  mono_class_setup_properties (klass);
  D.27905 = klass->ext;
  D.27906 = D.27905->property.count;
  if (D.27906 != 0) goto <D.27907>; else goto <D.27908>;
  <D.27907>:
  D.27905 = klass->ext;
  D.27909 = D.27905->properties;
  *iter = D.27909;
  D.27901 = *iter;
  return D.27901;
  <D.27908>:
  D.27901 = 0B;
  return D.27901;
  <D.27904>:
  property = *iter;
  property = property + 40;
  D.27905 = klass->ext;
  D.27909 = D.27905->properties;
  D.27905 = klass->ext;
  D.27906 = D.27905->property.count;
  D.27910 = (long unsigned int) D.27906;
  D.27911 = D.27910 * 40;
  D.27912 = D.27909 + D.27911;
  if (D.27912 > property) goto <D.27913>; else goto <D.27914>;
  <D.27913>:
  *iter = property;
  D.27901 = *iter;
  return D.27901;
  <D.27914>:
  D.27901 = 0B;
  return D.27901;
}


mono_class_get_events (struct MonoClass * klass, void * * iter)
{
  struct MonoEvent * D.27918;
  void * D.27919;
  struct MonoClassExt * D.27922;
  unsigned int D.27923;
  struct MonoEvent * D.27926;
  long unsigned int D.27927;
  long unsigned int D.27928;
  struct MonoEvent * D.27929;
  struct MonoEvent * event;

  if (iter == 0B) goto <D.27916>; else goto <D.27917>;
  <D.27916>:
  D.27918 = 0B;
  return D.27918;
  <D.27917>:
  D.27919 = *iter;
  if (D.27919 == 0B) goto <D.27920>; else goto <D.27921>;
  <D.27920>:
  mono_class_setup_events (klass);
  D.27922 = klass->ext;
  D.27923 = D.27922->event.count;
  if (D.27923 != 0) goto <D.27924>; else goto <D.27925>;
  <D.27924>:
  D.27922 = klass->ext;
  D.27926 = D.27922->events;
  *iter = D.27926;
  D.27918 = *iter;
  return D.27918;
  <D.27925>:
  D.27918 = 0B;
  return D.27918;
  <D.27921>:
  event = *iter;
  event = event + 56;
  D.27922 = klass->ext;
  D.27926 = D.27922->events;
  D.27922 = klass->ext;
  D.27923 = D.27922->event.count;
  D.27927 = (long unsigned int) D.27923;
  D.27928 = D.27927 * 56;
  D.27929 = D.27926 + D.27928;
  if (D.27929 > event) goto <D.27930>; else goto <D.27931>;
  <D.27930>:
  *iter = event;
  D.27918 = *iter;
  return D.27918;
  <D.27931>:
  D.27918 = 0B;
  return D.27918;
}


mono_class_get_interfaces (struct MonoClass * klass, void * * iter)
{
  struct MonoClass * D.27935;
  void * D.27936;
  long unsigned int D.27939;
  long unsigned int D.27940;
  long unsigned int D.27943;
  int D.27946;
  short unsigned int D.27949;
  struct MonoClass * * D.27952;
  long unsigned int D.27953;
  long unsigned int D.27954;
  struct MonoClass * * D.27955;
  struct MonoError error;
  struct MonoClass * * iface;

  try
    {
      if (iter == 0B) goto <D.27933>; else goto <D.27934>;
      <D.27933>:
      D.27935 = 0B;
      return D.27935;
      <D.27934>:
      D.27936 = *iter;
      if (D.27936 == 0B) goto <D.27937>; else goto <D.27938>;
      <D.27937>:
      D.27939 = BIT_FIELD_REF <*klass, 64, 256>;
      D.27940 = D.27939 & 9223372036854775808;
      if (D.27940 == 0) goto <D.27941>; else goto <D.27942>;
      <D.27941>:
      mono_class_init (klass);
      <D.27942>:
      D.27939 = BIT_FIELD_REF <*klass, 64, 256>;
      D.27943 = D.27939 & 2147483648;
      if (D.27943 == 0) goto <D.27944>; else goto <D.27945>;
      <D.27944>:
      mono_class_setup_interfaces (klass, &error);
      D.27946 = mono_error_ok (&error);
      if (D.27946 == 0) goto <D.27947>; else goto <D.27948>;
      <D.27947>:
      mono_error_cleanup (&error);
      D.27935 = 0B;
      return D.27935;
      <D.27948>:
      <D.27945>:
      D.27949 = klass->interface_count;
      if (D.27949 != 0) goto <D.27950>; else goto <D.27951>;
      <D.27950>:
      D.27952 = klass->interfaces;
      *iter = D.27952;
      D.27952 = klass->interfaces;
      D.27935 = *D.27952;
      return D.27935;
      <D.27951>:
      D.27935 = 0B;
      return D.27935;
      <D.27938>:
      iface = *iter;
      iface = iface + 8;
      D.27952 = klass->interfaces;
      D.27949 = klass->interface_count;
      D.27953 = (long unsigned int) D.27949;
      D.27954 = D.27953 * 8;
      D.27955 = D.27952 + D.27954;
      if (D.27955 > iface) goto <D.27956>; else goto <D.27957>;
      <D.27956>:
      *iter = iface;
      D.27935 = *iface;
      return D.27935;
      <D.27957>:
      D.27935 = 0B;
      return D.27935;
    }
  finally
    {
      error = {CLOBBER};
    }
}


mono_class_get_nested_types (struct MonoClass * klass, void * * iter)
{
  struct MonoClass * D.27962;
  long unsigned int D.27963;
  long unsigned int D.27964;
  unsigned int D.27967;
  struct MonoImage * D.27972;
  unsigned int D.27973;
  struct MonoTableInfo * D.27974;
  int D.27975;
  unsigned int D.27976;
  unsigned int D.27977;
  int D.27978;
  int D.27981;
  unsigned int D.27982;
  unsigned int D.27983;
  struct MonoClassExt * D.27984;
  struct GList * D.27985;
  struct GList * D.27986;
  unsigned int D.27987;
  void * D.27988;
  struct MonoError error;
  struct GList * item;
  int i;

  try
    {
      if (iter == 0B) goto <D.27960>; else goto <D.27961>;
      <D.27960>:
      D.27962 = 0B;
      return D.27962;
      <D.27961>:
      D.27963 = BIT_FIELD_REF <*klass, 64, 256>;
      D.27964 = D.27963 & 4294967296;
      if (D.27964 == 0) goto <D.27965>; else goto <D.27966>;
      <D.27965>:
      D.27967 = klass->type_token;
      if (D.27967 == 0) goto <D.27968>; else goto <D.27969>;
      <D.27968>:
      klass->nested_classes_inited = 1;
      <D.27969>:
      mono_loader_lock ();
      D.27963 = BIT_FIELD_REF <*klass, 64, 256>;
      D.27964 = D.27963 & 4294967296;
      if (D.27964 == 0) goto <D.27970>; else goto <D.27971>;
      <D.27970>:
      D.27972 = klass->image;
      D.27967 = klass->type_token;
      D.27973 = mono_metadata_nesting_typedef (D.27972, D.27967, 1);
      i = (int) D.27973;
      goto <D.21029>;
      <D.21030>:
      {
        struct MonoClass * nclass;
        guint32 cols[2];

        try
          {
            D.27972 = klass->image;
            D.27974 = &D.27972->tables[41];
            D.27975 = i + -1;
            mono_metadata_decode_row (D.27974, D.27975, &cols, 2);
            D.27972 = klass->image;
            D.27976 = cols[0];
            D.27977 = D.27976 | 33554432;
            nclass = mono_class_create_from_typedef (D.27972, D.27977, &error);
            D.27978 = mono_error_ok (&error);
            if (D.27978 == 0) goto <D.27979>; else goto <D.27980>;
            <D.27979>:
            mono_error_cleanup (&error);
            D.27972 = klass->image;
            D.27967 = klass->type_token;
            D.27981 = i + 1;
            D.27982 = (unsigned int) D.27981;
            D.27983 = mono_metadata_nesting_typedef (D.27972, D.27967, D.27982);
            i = (int) D.27983;
            // predicted unlikely by continue predictor.
            goto <D.21029>;
            <D.27980>:
            mono_class_alloc_ext (klass);
            D.27984 = klass->ext;
            D.27972 = klass->image;
            D.27984 = klass->ext;
            D.27985 = D.27984->nested_classes;
            D.27986 = g_list_prepend_image (D.27972, D.27985, nclass);
            D.27984->nested_classes = D.27986;
            D.27972 = klass->image;
            D.27967 = klass->type_token;
            D.27981 = i + 1;
            D.27982 = (unsigned int) D.27981;
            D.27987 = mono_metadata_nesting_typedef (D.27972, D.27967, D.27982);
            i = (int) D.27987;
          }
        finally
          {
            cols = {CLOBBER};
          }
      }
      <D.21029>:
      if (i != 0) goto <D.21030>; else goto <D.21031>;
      <D.21031>:
      <D.27971>:
      mono_memory_barrier ();
      klass->nested_classes_inited = 1;
      mono_loader_unlock ();
      <D.27966>:
      D.27988 = *iter;
      if (D.27988 == 0B) goto <D.27989>; else goto <D.27990>;
      <D.27989>:
      D.27984 = klass->ext;
      if (D.27984 != 0B) goto <D.27992>; else goto <D.27991>;
      <D.27992>:
      D.27984 = klass->ext;
      D.27985 = D.27984->nested_classes;
      if (D.27985 != 0B) goto <D.27993>; else goto <D.27991>;
      <D.27993>:
      D.27984 = klass->ext;
      D.27985 = D.27984->nested_classes;
      *iter = D.27985;
      D.27984 = klass->ext;
      D.27985 = D.27984->nested_classes;
      D.27962 = D.27985->data;
      return D.27962;
      <D.27991>:
      D.27962 = 0B;
      return D.27962;
      <D.27990>:
      item = *iter;
      item = item->next;
      if (item != 0B) goto <D.27994>; else goto <D.27995>;
      <D.27994>:
      *iter = item;
      D.27962 = item->data;
      return D.27962;
      <D.27995>:
      D.27962 = 0B;
      return D.27962;
    }
  finally
    {
      error = {CLOBBER};
    }
}


mono_class_is_delegate (struct MonoClass * klass)
{
  mono_bool D.28000;
  <unnamed-unsigned:1> D.28001;

  D.28001 = klass->delegate;
  D.28000 = (mono_bool) D.28001;
  return D.28000;
}


mono_class_implements_interface (struct MonoClass * klass, struct MonoClass * iface)
{
  mono_bool D.28003;

  D.28003 = mono_class_is_assignable_from (iface, klass);
  return D.28003;
}


mono_field_get_name (struct MonoClassField * field)
{
  const char * D.28005;

  D.28005 = field->name;
  return D.28005;
}


mono_field_get_type (struct MonoClassField * field)
{
  int D.28007;
  const char * D.28010;
  struct MonoType * D.28011;
  struct MonoError error;
  struct MonoType * type;

  try
    {
      type = mono_field_get_type_checked (field, &error);
      D.28007 = mono_error_ok (&error);
      if (D.28007 == 0) goto <D.28008>; else goto <D.28009>;
      <D.28008>:
      D.28010 = mono_error_get_message (&error);
      mono_trace (16, 2, "Could not load field\'s type due to %s", D.28010);
      mono_error_cleanup (&error);
      <D.28009>:
      D.28011 = type;
      return D.28011;
    }
  finally
    {
      error = {CLOBBER};
    }
}


__attribute__((visibility ("hidden")))
mono_field_get_type_checked (struct MonoClassField * field, struct MonoError * error)
{
  struct MonoType * D.28014;
  struct MonoType * D.28017;

  mono_error_init (error);
  D.28014 = field->type;
  if (D.28014 == 0B) goto <D.28015>; else goto <D.28016>;
  <D.28015>:
  mono_field_resolve_type (field, error);
  <D.28016>:
  D.28017 = field->type;
  return D.28017;
}


mono_field_get_parent (struct MonoClassField * field)
{
  struct MonoClass * D.28019;

  D.28019 = field->parent;
  return D.28019;
}


mono_field_get_flags (struct MonoClassField * field)
{
  struct MonoType * D.28021;
  uint32_t D.28024;
  short unsigned int D.28025;

  D.28021 = field->type;
  if (D.28021 == 0B) goto <D.28022>; else goto <D.28023>;
  <D.28022>:
  D.28024 = mono_field_resolve_flags (field);
  return D.28024;
  <D.28023>:
  D.28021 = field->type;
  D.28025 = D.28021->attrs;
  D.28024 = (uint32_t) D.28025;
  return D.28024;
}


mono_field_resolve_flags (struct MonoClassField * field)
{
  struct MonoClass * iftmp.271;
  struct MonoGenericClass * D.28028;
  long int field.272;
  struct MonoClassField * D.28033;
  long int D.28034;
  long int D.28035;
  long int D.28036;
  struct MonoClassField * D.28039;
  long unsigned int D.28040;
  long unsigned int D.28041;
  guint32 D.28042;
  unsigned int D.28043;
  unsigned int field_idx.273;
  unsigned int D.28045;
  long unsigned int D.28046;
  long unsigned int D.28047;
  _Bool D.28048;
  long int D.28049;
  long int D.28050;
  struct MonoClass * class;
  struct MonoImage * image;
  struct MonoClass * gtd;
  int field_idx;

  class = field->parent;
  image = class->image;
  D.28028 = class->generic_class;
  if (D.28028 != 0B) goto <D.28029>; else goto <D.28030>;
  <D.28029>:
  iftmp.271 = mono_class_get_generic_type_definition (class);
  goto <D.28031>;
  <D.28030>:
  iftmp.271 = 0B;
  <D.28031>:
  gtd = iftmp.271;
  field.272 = (long int) field;
  D.28033 = class->fields;
  D.28034 = (long int) D.28033;
  D.28035 = field.272 - D.28034;
  D.28036 = D.28035 /[ex] 32;
  field_idx = (int) D.28036;
  if (gtd != 0B) goto <D.28037>; else goto <D.28038>;
  <D.28037>:
  {
    struct MonoClassField * gfield;

    D.28039 = gtd->fields;
    D.28040 = (long unsigned int) field_idx;
    D.28041 = D.28040 * 32;
    gfield = D.28039 + D.28041;
    D.28042 = mono_field_get_flags (gfield);
    return D.28042;
  }
  <D.28038>:
  {
    int idx;

    D.28043 = class->field.first;
    field_idx.273 = (unsigned int) field_idx;
    D.28045 = D.28043 + field_idx.273;
    idx = (int) D.28045;
    D.28046 = BIT_FIELD_REF <*image, 64, 192>;
    D.28047 = D.28046 & 268435456;
    D.28048 = D.28047 != 0;
    D.28049 = (long int) D.28048;
    D.28050 = __builtin_expect (D.28049, 0);
    if (D.28050 != 0) goto <D.28051>; else goto <D.28052>;
    <D.28051>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "class.c", 10164, "!image->dynamic");
    <D.28052>:
    D.28042 = mono_metadata_decode_table_row_col (image, 4, idx, 0);
    return D.28042;
  }
}


mono_field_get_offset (struct MonoClassField * field)
{
  uint32_t D.28054;
  int D.28055;

  D.28055 = field->offset;
  D.28054 = (uint32_t) D.28055;
  return D.28054;
}


mono_field_get_data (struct MonoClassField * field)
{
  struct MonoType * D.28057;
  short unsigned int D.28058;
  signed short D.28059;
  const char * D.28062;
  int D.28063;
  int D.28064;

  D.28057 = field->type;
  D.28058 = D.28057->attrs;
  D.28059 = (signed short) D.28058;
  if (D.28059 < 0) goto <D.28060>; else goto <D.28061>;
  <D.28060>:
  {
    MonoTypeEnum def_type;

    try
      {
        D.28062 = mono_class_get_field_default_value (field, &def_type);
        return D.28062;
      }
    finally
      {
        def_type = {CLOBBER};
      }
  }
  <D.28061>:
  D.28057 = field->type;
  D.28058 = D.28057->attrs;
  D.28063 = (int) D.28058;
  D.28064 = D.28063 & 256;
  if (D.28064 != 0) goto <D.28065>; else goto <D.28066>;
  <D.28065>:
  D.28062 = mono_field_get_rva (field);
  return D.28062;
  <D.28066>:
  D.28062 = 0B;
  return D.28062;
}


mono_field_get_rva (struct MonoClassField * field)
{
  struct MonoType * D.28069;
  short unsigned int D.28070;
  int D.28071;
  int D.28072;
  _Bool D.28073;
  long int D.28074;
  long int D.28075;
  struct MonoClassExt * D.28080;
  struct MonoFieldDefaultValue * D.28082;
  unsigned int D.28085;
  unsigned int D.28086;
  int D.28087;
  void * D.28088;
  long unsigned int D.28089;
  long unsigned int D.28090;
  struct MonoFieldDefaultValue * D.28091;
  const char * D.28092;
  struct MonoImage * D.28095;
  long unsigned int D.28096;
  long unsigned int D.28097;
  struct MonoClass * D.28100;
  struct MonoImage * D.28101;
  unsigned int D.28102;
  unsigned int field_index.274;
  unsigned int D.28104;
  unsigned int rva.275;
  const char * D.28108;
  const char * D.28109;
  char * D.28110;
  const char * D.28111;
  guint32 rva;
  int field_index;
  struct MonoClass * klass;

  try
    {
      klass = field->parent;
      D.28069 = field->type;
      D.28070 = D.28069->attrs;
      D.28071 = (int) D.28070;
      D.28072 = D.28071 & 256;
      D.28073 = D.28072 == 0;
      D.28074 = (long int) D.28073;
      D.28075 = __builtin_expect (D.28074, 0);
      if (D.28075 != 0) goto <D.28076>; else goto <D.28077>;
      <D.28076>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "class.c", 9062, "field->type->attrs & FIELD_ATTRIBUTE_HAS_FIELD_RVA");
      <D.28077>:
      D.28080 = klass->ext;
      if (D.28080 == 0B) goto <D.28078>; else goto <D.28081>;
      <D.28081>:
      D.28080 = klass->ext;
      D.28082 = D.28080->field_def_values;
      if (D.28082 == 0B) goto <D.28078>; else goto <D.28079>;
      <D.28078>:
      mono_loader_lock ();
      mono_class_alloc_ext (klass);
      D.28080 = klass->ext;
      D.28082 = D.28080->field_def_values;
      if (D.28082 == 0B) goto <D.28083>; else goto <D.28084>;
      <D.28083>:
      D.28080 = klass->ext;
      D.28085 = klass->field.count;
      D.28086 = D.28085 * 16;
      D.28087 = (int) D.28086;
      D.28088 = mono_class_alloc0 (klass, D.28087);
      D.28080->field_def_values = D.28088;
      <D.28084>:
      mono_loader_unlock ();
      <D.28079>:
      field_index = mono_field_get_index (field);
      D.28080 = klass->ext;
      D.28082 = D.28080->field_def_values;
      D.28089 = (long unsigned int) field_index;
      D.28090 = D.28089 * 16;
      D.28091 = D.28082 + D.28090;
      D.28092 = D.28091->data;
      if (D.28092 == 0B) goto <D.28093>; else goto <D.28094>;
      <D.28093>:
      D.28095 = klass->image;
      D.28096 = BIT_FIELD_REF <*D.28095, 64, 192>;
      D.28097 = D.28096 & 268435456;
      if (D.28097 == 0) goto <D.28098>; else goto <D.28099>;
      <D.28098>:
      D.28100 = field->parent;
      D.28101 = D.28100->image;
      D.28102 = klass->field.first;
      field_index.274 = (unsigned int) field_index;
      D.28104 = D.28102 + field_index.274;
      mono_metadata_field_info (D.28101, D.28104, 0B, &rva, 0B);
      rva.275 = rva;
      if (rva.275 == 0) goto <D.28106>; else goto <D.28107>;
      <D.28106>:
      D.28108 = mono_field_get_name (field);
      D.28100 = field->parent;
      D.28109 = D.28100->name;
      monoeg_g_log (0B, 16, "field %s in %s should have RVA data, but hasn\'t", D.28108, D.28109);
      <D.28107>:
      D.28080 = klass->ext;
      D.28082 = D.28080->field_def_values;
      D.28089 = (long unsigned int) field_index;
      D.28090 = D.28089 * 16;
      D.28091 = D.28082 + D.28090;
      D.28100 = field->parent;
      D.28101 = D.28100->image;
      rva.275 = rva;
      D.28110 = mono_image_rva_map (D.28101, rva.275);
      D.28091->data = D.28110;
      <D.28099>:
      <D.28094>:
      D.28080 = klass->ext;
      D.28082 = D.28080->field_def_values;
      D.28089 = (long unsigned int) field_index;
      D.28090 = D.28089 * 16;
      D.28091 = D.28082 + D.28090;
      D.28111 = D.28091->data;
      return D.28111;
    }
  finally
    {
      rva = {CLOBBER};
    }
}


mono_property_get_name (struct MonoProperty * prop)
{
  const char * D.28114;

  D.28114 = prop->name;
  return D.28114;
}


mono_property_get_set_method (struct MonoProperty * prop)
{
  struct MonoMethod * D.28116;

  D.28116 = prop->set;
  return D.28116;
}


mono_property_get_get_method (struct MonoProperty * prop)
{
  struct MonoMethod * D.28118;

  D.28118 = prop->get;
  return D.28118;
}


mono_property_get_parent (struct MonoProperty * prop)
{
  struct MonoClass * D.28120;

  D.28120 = prop->parent;
  return D.28120;
}


mono_property_get_flags (struct MonoProperty * prop)
{
  uint32_t D.28122;

  D.28122 = prop->attrs;
  return D.28122;
}


mono_event_get_name (struct MonoEvent * event)
{
  const char * D.28124;

  D.28124 = event->name;
  return D.28124;
}


mono_event_get_add_method (struct MonoEvent * event)
{
  struct MonoMethod * D.28126;

  D.28126 = event->add;
  return D.28126;
}


mono_event_get_remove_method (struct MonoEvent * event)
{
  struct MonoMethod * D.28128;

  D.28128 = event->remove;
  return D.28128;
}


mono_event_get_raise_method (struct MonoEvent * event)
{
  struct MonoMethod * D.28130;

  D.28130 = event->raise;
  return D.28130;
}


mono_event_get_parent (struct MonoEvent * event)
{
  struct MonoClass * D.28132;

  D.28132 = event->parent;
  return D.28132;
}


mono_event_get_flags (struct MonoEvent * event)
{
  uint32_t D.28134;

  D.28134 = event->attrs;
  return D.28134;
}


mono_class_get_method_from_name (struct MonoClass * klass, const char * name, int param_count)
{
  struct MonoMethod * D.28136;

  D.28136 = mono_class_get_method_from_name_flags (klass, name, param_count, 0);
  return D.28136;
}


mono_class_get_method_from_name_flags (struct MonoClass * klass, const char * name, int param_count, int flags)
{
  struct MonoGenericClass * D.28138;
  struct MonoMethod * * D.28141;
  struct MonoClass * D.28144;
  struct MonoGenericContext * D.28147;
  struct MonoMethod * D.28148;
  unsigned int D.28153;
  struct MonoImage * D.28155;
  long unsigned int D.28156;
  long unsigned int D.28157;
  long unsigned int D.28161;
  long unsigned int D.28162;
  struct MonoMethod * * D.28163;
  const char * D.28166;
  char D.28167;
  char D.28168;
  int D.28171;
  struct MonoMethodSignature * D.28175;
  short unsigned int D.28176;
  int D.28177;
  short unsigned int D.28178;
  int D.28179;
  int D.28180;
  unsigned int D.28183;
  unsigned int i.276;
  struct MonoMethod * res;
  int i;

  res = 0B;
  mono_class_init (klass);
  D.28138 = klass->generic_class;
  if (D.28138 != 0B) goto <D.28139>; else goto <D.28140>;
  <D.28139>:
  D.28141 = klass->methods;
  if (D.28141 == 0B) goto <D.28142>; else goto <D.28143>;
  <D.28142>:
  D.28138 = klass->generic_class;
  D.28144 = D.28138->container_class;
  res = mono_class_get_method_from_name_flags (D.28144, name, param_count, flags);
  if (res != 0B) goto <D.28145>; else goto <D.28146>;
  <D.28145>:
  D.28147 = mono_class_get_context (klass);
  res = mono_class_inflate_generic_method_full (res, klass, D.28147);
  <D.28146>:
  D.28148 = res;
  return D.28148;
  <D.28143>:
  <D.28140>:
  D.28141 = klass->methods;
  if (D.28141 != 0B) goto <D.28149>; else goto <D.28152>;
  <D.28152>:
  D.28153 = klass->type_token;
  if (D.28153 == 0) goto <D.28149>; else goto <D.28154>;
  <D.28154>:
  D.28155 = klass->image;
  D.28156 = BIT_FIELD_REF <*D.28155, 64, 192>;
  D.28157 = D.28156 & 268435456;
  if (D.28157 != 0) goto <D.28149>; else goto <D.28158>;
  <D.28158>:
  D.28138 = klass->generic_class;
  if (D.28138 != 0B) goto <D.28149>; else goto <D.28150>;
  <D.28149>:
  mono_class_setup_methods (klass);
  D.28141 = klass->methods;
  if (D.28141 == 0B) goto <D.28159>; else goto <D.28160>;
  <D.28159>:
  D.28148 = 0B;
  return D.28148;
  <D.28160>:
  i = 0;
  goto <D.21133>;
  <D.21132>:
  {
    struct MonoMethod * method;

    D.28141 = klass->methods;
    D.28161 = (long unsigned int) i;
    D.28162 = D.28161 * 8;
    D.28163 = D.28141 + D.28162;
    method = *D.28163;
    D.28166 = method->name;
    D.28167 = *D.28166;
    D.28168 = *name;
    if (D.28167 == D.28168) goto <D.28169>; else goto <D.28170>;
    <D.28169>:
    D.28166 = method->name;
    D.28171 = strcmp (name, D.28166);
    if (D.28171 == 0) goto <D.28172>; else goto <D.28173>;
    <D.28172>:
    if (param_count == -1) goto <D.28164>; else goto <D.28174>;
    <D.28174>:
    D.28175 = mono_method_signature (method);
    D.28176 = D.28175->param_count;
    D.28177 = (int) D.28176;
    if (D.28177 == param_count) goto <D.28164>; else goto <D.28165>;
    <D.28164>:
    D.28178 = method->flags;
    D.28179 = (int) D.28178;
    D.28180 = D.28179 & flags;
    if (D.28180 == flags) goto <D.28181>; else goto <D.28182>;
    <D.28181>:
    res = method;
    goto <D.21131>;
    <D.28182>:
    <D.28165>:
    <D.28173>:
    <D.28170>:
  }
  i = i + 1;
  <D.21133>:
  D.28183 = klass->method.count;
  i.276 = (unsigned int) i;
  if (D.28183 > i.276) goto <D.21132>; else goto <D.21131>;
  <D.21131>:
  goto <D.28151>;
  <D.28150>:
  res = find_method_in_metadata (klass, name, param_count, flags);
  <D.28151>:
  D.28148 = res;
  return D.28148;
}


__attribute__((visibility ("hidden")))
mono_class_set_failure (struct MonoClass * klass, guint32 ex_type, void * ex_data)
{
  unsigned char D.28186;
  gboolean D.28189;
  unsigned char D.28190;
  struct MonoImage * D.28193;

  D.28186 = klass->exception_type;
  if (D.28186 != 0) goto <D.28187>; else goto <D.28188>;
  <D.28187>:
  D.28189 = 0;
  return D.28189;
  <D.28188>:
  mono_loader_lock ();
  D.28190 = (unsigned char) ex_type;
  klass->exception_type = D.28190;
  if (ex_data != 0B) goto <D.28191>; else goto <D.28192>;
  <D.28191>:
  D.28193 = klass->image;
  mono_image_property_insert (D.28193, klass, 0, ex_data);
  <D.28192>:
  mono_loader_unlock ();
  D.28189 = 1;
  return D.28189;
}


__attribute__((visibility ("hidden")))
mono_class_get_exception_data (struct MonoClass * klass)
{
  void * D.28195;
  struct MonoImage * D.28196;

  D.28196 = klass->image;
  D.28195 = mono_image_property_lookup (D.28196, klass, 0);
  return D.28195;
}


__attribute__((visibility ("hidden")))
mono_classes_init ()
{
  mono_counters_register ("Inflated methods size", 2048, &inflated_methods_size);
  mono_counters_register ("Inflated classes", 2048, &inflated_classes);
  mono_counters_register ("Inflated classes size", 2048, &inflated_classes_size);
  mono_counters_register ("MonoClass size", 1024, &classes_size);
  mono_counters_register ("MonoClassExt size", 1024, &class_ext_size);
}


__attribute__((visibility ("hidden")))
mono_classes_cleanup ()
{
  struct MonoBitSet * global_interface_bitset.277;

  global_interface_bitset.277 = global_interface_bitset;
  if (global_interface_bitset.277 != 0B) goto <D.28199>; else goto <D.28200>;
  <D.28199>:
  global_interface_bitset.277 = global_interface_bitset;
  mono_bitset_free (global_interface_bitset.277);
  <D.28200>:
  global_interface_bitset = 0B;
}


__attribute__((visibility ("hidden")))
mono_class_get_exception_for_failure (struct MonoClass * klass)
{
  unsigned char D.28201;
  int D.28202;
  guint32 iftmp.278;
  struct MonoImage * D.28207;
  struct MonoAssembly * D.28208;
  struct MonoReflectionAssembly * D.28209;
  struct MonoType * D.28210;
  struct MonoReflectionType * D.28211;
  void * iftmp.279;
  struct MonoMethod * D.28216;
  struct MonoException * D.28217;
  char * iftmp.280;
  struct MonoAssembly * D.28219;
  struct MonoAssemblyName * D.28222;
  struct MonoDomain * D.28224;
  long unsigned int D.28225;
  sizetype D.28226;
  long unsigned int D.28227;
  sizetype D.28228;
  long unsigned int D.28229;
  sizetype D.28230;
  struct MonoDomain * D.28231;
  struct MonoString * D.28232;
  void * exception_data;

  exception_data = mono_class_get_exception_data (klass);
  D.28201 = klass->exception_type;
  D.28202 = (int) D.28201;
  switch (D.28202) <default: <D.21176>, case 2: <D.21152>, case 5: <D.21164>, case 6: <D.21167>, case 7: <D.21159>, case 8: <D.21170>, case 12: <D.21175>>
  <D.21152>:
  {
    struct MonoDomain * domain;
    struct MonoSecurityManager * secman;
    struct MonoMethod * method;
    guint32 error;
    struct MonoObject * exc;
    void * args[4];

    try
      {
        domain = mono_domain_get ();
        secman = mono_security_manager_get_methods ();
        method = exception_data;
        if (method != 0B) goto <D.28204>; else goto <D.28205>;
        <D.28204>:
        iftmp.278 = 2;
        goto <D.28206>;
        <D.28205>:
        iftmp.278 = 1;
        <D.28206>:
        error = iftmp.278;
        exc = 0B;
        args[0] = &error;
        D.28207 = klass->image;
        D.28208 = mono_image_get_assembly (D.28207);
        D.28209 = mono_assembly_get_object (domain, D.28208);
        args[1] = D.28209;
        D.28210 = &klass->byval_arg;
        D.28211 = mono_type_get_object (domain, D.28210);
        args[2] = D.28211;
        if (method != 0B) goto <D.28213>; else goto <D.28214>;
        <D.28213>:
        iftmp.279 = mono_method_get_object (domain, method, 0B);
        goto <D.28215>;
        <D.28214>:
        iftmp.279 = 0B;
        <D.28215>:
        args[3] = iftmp.279;
        D.28216 = secman->inheritsecurityexception;
        mono_runtime_invoke (D.28216, 0B, &args, &exc);
        D.28217 = exc;
        return D.28217;
      }
    finally
      {
        error = {CLOBBER};
        exc = {CLOBBER};
        args = {CLOBBER};
      }
  }
  <D.21159>:
  {
    struct MonoString * name;
    struct MonoException * ex;
    char * str;
    char * astr;

    str = mono_type_get_full_name (klass);
    D.28207 = klass->image;
    D.28219 = D.28207->assembly;
    if (D.28219 != 0B) goto <D.28220>; else goto <D.28221>;
    <D.28220>:
    D.28207 = klass->image;
    D.28219 = D.28207->assembly;
    D.28222 = &D.28219->aname;
    iftmp.280 = mono_stringify_assembly_name (D.28222);
    goto <D.28223>;
    <D.28221>:
    iftmp.280 = 0B;
    <D.28223>:
    astr = iftmp.280;
    D.28224 = mono_domain_get ();
    name = mono_string_new (D.28224, str);
    monoeg_g_free (str);
    ex = mono_get_exception_type_load (name, astr);
    monoeg_g_free (astr);
    D.28217 = ex;
    return D.28217;
  }
  <D.21164>:
  {
    char * class_name;
    char * assembly_name;

    class_name = exception_data;
    D.28225 = __strlen_g (class_name);
    D.28226 = D.28225 + 1;
    assembly_name = class_name + D.28226;
    D.28217 = mono_get_exception_missing_method (class_name, assembly_name);
    return D.28217;
  }
  <D.21167>:
  {
    char * class_name;
    char * member_name;

    class_name = exception_data;
    D.28227 = __strlen_g (class_name);
    D.28228 = D.28227 + 1;
    member_name = class_name + D.28228;
    D.28217 = mono_get_exception_missing_field (class_name, member_name);
    return D.28217;
  }
  <D.21170>:
  {
    char * msg_format;
    char * assembly_name;
    char * msg;
    struct MonoException * ex;

    msg_format = exception_data;
    D.28229 = __strlen_g (msg_format);
    D.28230 = D.28229 + 1;
    assembly_name = msg_format + D.28230;
    msg = monoeg_g_strdup_printf (msg_format, assembly_name);
    D.28231 = mono_domain_get ();
    D.28232 = mono_string_new (D.28231, assembly_name);
    ex = mono_get_exception_file_not_found2 (msg, D.28232);
    monoeg_g_free (msg);
    D.28217 = ex;
    return D.28217;
  }
  <D.21175>:
  D.28217 = mono_get_exception_bad_image_format (exception_data);
  return D.28217;
  <D.21176>:
  {
    struct MonoLoaderError * error;
    struct MonoException * ex;

    error = mono_loader_get_last_error ();
    if (error != 0B) goto <D.28233>; else goto <D.28234>;
    <D.28233>:
    ex = mono_loader_error_prepare_exception (error);
    D.28217 = ex;
    return D.28217;
    <D.28234>:
    D.28217 = 0B;
    return D.28217;
  }
}


__attribute__((visibility ("hidden")))
mono_class_get_generic_type_definition (struct MonoClass * klass)
{
  struct MonoClass * D.28237;
  struct MonoClass * iftmp.281;
  struct MonoGenericClass * D.28239;

  D.28239 = klass->generic_class;
  if (D.28239 != 0B) goto <D.28240>; else goto <D.28241>;
  <D.28240>:
  D.28239 = klass->generic_class;
  iftmp.281 = D.28239->container_class;
  goto <D.28242>;
  <D.28241>:
  iftmp.281 = klass;
  <D.28242>:
  D.28237 = iftmp.281;
  return D.28237;
}


__attribute__((visibility ("hidden")))
mono_class_has_parent_and_ignore_generics (struct MonoClass * klass, struct MonoClass * parent)
{
  struct MonoClass * * D.28244;
  long unsigned int D.28245;
  long unsigned int D.28246;
  struct MonoClass * * D.28247;
  struct MonoClass * D.28248;
  struct MonoClass * D.28249;
  gboolean D.28252;
  short unsigned int D.28253;
  int D.28254;
  int i;

  klass = mono_class_get_generic_type_definition (klass);
  parent = mono_class_get_generic_type_definition (parent);
  mono_class_setup_supertypes (klass);
  i = 0;
  goto <D.21194>;
  <D.21193>:
  D.28244 = klass->supertypes;
  D.28245 = (long unsigned int) i;
  D.28246 = D.28245 * 8;
  D.28247 = D.28244 + D.28246;
  D.28248 = *D.28247;
  D.28249 = mono_class_get_generic_type_definition (D.28248);
  if (D.28249 == parent) goto <D.28250>; else goto <D.28251>;
  <D.28250>:
  D.28252 = 1;
  return D.28252;
  <D.28251>:
  i = i + 1;
  <D.21194>:
  D.28253 = klass->idepth;
  D.28254 = (int) D.28253;
  if (D.28254 > i) goto <D.21193>; else goto <D.21195>;
  <D.21195>:
  D.28252 = 0;
  return D.28252;
}


mono_method_can_access_field (struct MonoMethod * method, struct MonoClassField * field)
{
  struct MonoClass * D.28256;
  struct MonoClass * D.28257;
  struct MonoType * D.28258;
  short unsigned int D.28259;
  int D.28260;
  int D.28261;
  struct MonoType * D.28264;
  short unsigned int D.28265;
  int D.28266;
  int D.28267;
  mono_bool D.28270;
  int can;

  D.28256 = method->klass;
  D.28257 = field->parent;
  D.28258 = mono_field_get_type (field);
  D.28259 = D.28258->attrs;
  D.28260 = (int) D.28259;
  D.28261 = D.28260 & 7;
  can = can_access_member (D.28256, D.28257, 0B, D.28261);
  if (can == 0) goto <D.28262>; else goto <D.28263>;
  <D.28262>:
  {
    struct MonoClass * nested;

    D.28256 = method->klass;
    nested = D.28256->nested_in;
    goto <D.21268>;
    <D.21267>:
    D.28257 = field->parent;
    D.28264 = mono_field_get_type (field);
    D.28265 = D.28264->attrs;
    D.28266 = (int) D.28265;
    D.28267 = D.28266 & 7;
    can = can_access_member (nested, D.28257, 0B, D.28267);
    if (can != 0) goto <D.28268>; else goto <D.28269>;
    <D.28268>:
    D.28270 = 1;
    return D.28270;
    <D.28269>:
    nested = nested->nested_in;
    <D.21268>:
    if (nested != 0B) goto <D.21267>; else goto <D.21269>;
    <D.21269>:
  }
  <D.28263>:
  D.28270 = can;
  return D.28270;
}


can_access_member (struct MonoClass * access_klass, struct MonoClass * member_klass, struct MonoClass * context_klass, int access_level)
{
  struct MonoImage * D.28272;
  struct MonoAssembly * D.28273;
  unsigned char D.28276;
  gboolean D.28279;
  struct MonoGenericClass * D.28283;
  struct MonoClass * D.28285;
  struct MonoGenericContainer * D.28286;
  int D.28292;
  struct MonoImage * D.28295;
  _Bool D.28296;
  _Bool D.28297;
  int D.28298;
  struct MonoAssembly * D.28301;
  int D.28302;
  int D.28305;
  int D.28308;
  struct MonoClass * member_generic_def;

  D.28272 = access_klass->image;
  D.28273 = D.28272->assembly;
  if (D.28273 != 0B) goto <D.28274>; else goto <D.28275>;
  <D.28274>:
  D.28272 = access_klass->image;
  D.28273 = D.28272->assembly;
  D.28276 = D.28273->corlib_internal;
  if (D.28276 != 0) goto <D.28277>; else goto <D.28278>;
  <D.28277>:
  D.28279 = 1;
  return D.28279;
  <D.28278>:
  <D.28275>:
  D.28283 = access_klass->generic_class;
  if (D.28283 != 0B) goto <D.28284>; else goto <D.28280>;
  <D.28284>:
  D.28283 = access_klass->generic_class;
  D.28285 = D.28283->container_class;
  if (D.28285 != 0B) goto <D.28281>; else goto <D.28280>;
  <D.28280>:
  D.28286 = access_klass->generic_container;
  if (D.28286 != 0B) goto <D.28281>; else goto <D.28282>;
  <D.28281>:
  member_generic_def = get_generic_definition_class (member_klass);
  if (member_generic_def != 0B) goto <D.28287>; else goto <D.28288>;
  <D.28287>:
  {
    struct MonoClass * access_container;

    D.28286 = access_klass->generic_container;
    if (D.28286 != 0B) goto <D.28289>; else goto <D.28290>;
    <D.28289>:
    access_container = access_klass;
    goto <D.28291>;
    <D.28290>:
    D.28283 = access_klass->generic_class;
    access_container = D.28283->container_class;
    <D.28291>:
    D.28292 = can_access_member (access_container, member_generic_def, context_klass, access_level);
    if (D.28292 != 0) goto <D.28293>; else goto <D.28294>;
    <D.28293>:
    D.28279 = 1;
    return D.28279;
    <D.28294>:
  }
  <D.28288>:
  <D.28282>:
  switch (access_level) <default: <D.28311>, case 0: <D.21254>, case 1: <D.21255>, case 2: <D.21256>, case 3: <D.21257>, case 4: <D.21258>, case 5: <D.21259>, case 6: <D.21260>>
  <D.21254>:
  D.28272 = access_klass->image;
  D.28295 = member_klass->image;
  D.28296 = D.28272 == D.28295;
  D.28279 = (gboolean) D.28296;
  return D.28279;
  <D.21255>:
  D.28297 = access_klass == member_klass;
  D.28279 = (gboolean) D.28297;
  return D.28279;
  <D.21256>:
  D.28298 = is_valid_family_access (access_klass, member_klass, context_klass);
  if (D.28298 != 0) goto <D.28299>; else goto <D.28300>;
  <D.28299>:
  D.28272 = access_klass->image;
  D.28273 = D.28272->assembly;
  D.28295 = member_klass->image;
  D.28301 = D.28295->assembly;
  D.28302 = can_access_internals (D.28273, D.28301);
  if (D.28302 != 0) goto <D.28303>; else goto <D.28304>;
  <D.28303>:
  D.28279 = 1;
  return D.28279;
  <D.28304>:
  <D.28300>:
  D.28279 = 0;
  return D.28279;
  <D.21257>:
  D.28272 = access_klass->image;
  D.28273 = D.28272->assembly;
  D.28295 = member_klass->image;
  D.28301 = D.28295->assembly;
  D.28279 = can_access_internals (D.28273, D.28301);
  return D.28279;
  <D.21258>:
  D.28305 = is_valid_family_access (access_klass, member_klass, context_klass);
  if (D.28305 != 0) goto <D.28306>; else goto <D.28307>;
  <D.28306>:
  D.28279 = 1;
  return D.28279;
  <D.28307>:
  D.28279 = 0;
  return D.28279;
  <D.21259>:
  D.28308 = is_valid_family_access (access_klass, member_klass, context_klass);
  if (D.28308 != 0) goto <D.28309>; else goto <D.28310>;
  <D.28309>:
  D.28279 = 1;
  return D.28279;
  <D.28310>:
  D.28272 = access_klass->image;
  D.28273 = D.28272->assembly;
  D.28295 = member_klass->image;
  D.28301 = D.28295->assembly;
  D.28279 = can_access_internals (D.28273, D.28301);
  return D.28279;
  <D.21260>:
  D.28279 = 1;
  return D.28279;
  <D.28311>:
  D.28279 = 0;
  return D.28279;
}


get_generic_definition_class (struct MonoClass * klass)
{
  struct MonoGenericClass * D.28313;
  struct MonoClass * D.28316;
  struct MonoClass * D.28319;

  goto <D.21215>;
  <D.21214>:
  D.28313 = klass->generic_class;
  if (D.28313 != 0B) goto <D.28314>; else goto <D.28315>;
  <D.28314>:
  D.28313 = klass->generic_class;
  D.28316 = D.28313->container_class;
  if (D.28316 != 0B) goto <D.28317>; else goto <D.28318>;
  <D.28317>:
  D.28313 = klass->generic_class;
  D.28319 = D.28313->container_class;
  return D.28319;
  <D.28318>:
  <D.28315>:
  klass = klass->parent;
  <D.21215>:
  if (klass != 0B) goto <D.21214>; else goto <D.21216>;
  <D.21216>:
  D.28319 = 0B;
  return D.28319;
}


is_valid_family_access (struct MonoClass * access_klass, struct MonoClass * member_klass, struct MonoClass * context_klass)
{
  int D.28321;
  gboolean D.28324;
  int D.28329;

  D.28321 = mono_class_has_parent_and_ignore_generics (access_klass, member_klass);
  if (D.28321 == 0) goto <D.28322>; else goto <D.28323>;
  <D.28322>:
  D.28324 = 0;
  return D.28324;
  <D.28323>:
  if (context_klass == 0B) goto <D.28325>; else goto <D.28326>;
  <D.28325>:
  D.28324 = 1;
  return D.28324;
  <D.28326>:
  if (access_klass != member_klass) goto <D.28327>; else goto <D.28328>;
  <D.28327>:
  D.28329 = mono_class_has_parent_and_ignore_generics (context_klass, access_klass);
  if (D.28329 == 0) goto <D.28330>; else goto <D.28331>;
  <D.28330>:
  D.28324 = 0;
  return D.28324;
  <D.28331>:
  <D.28328>:
  D.28324 = 1;
  return D.28324;
}


can_access_internals (struct MonoAssembly * accessing, struct MonoAssembly * accessed)
{
  gboolean D.28335;
  <unnamed type> D.28339;
  struct MonoImage * D.28342;
  struct MonoImage * D.28343;
  int D.28344;
  const char * D.28347;
  const char * D.28350;
  int D.28351;
  unsigned char D.28354;
  unsigned char D.28357;
  mono_byte[17] * D.28360;
  mono_byte[17] * D.28361;
  int D.28362;
  struct GSList * tmp;

  if (accessing == accessed) goto <D.28333>; else goto <D.28334>;
  <D.28333>:
  D.28335 = 1;
  return D.28335;
  <D.28334>:
  if (accessed == 0B) goto <D.28336>; else goto <D.28338>;
  <D.28338>:
  if (accessing == 0B) goto <D.28336>; else goto <D.28337>;
  <D.28336>:
  D.28335 = 0;
  return D.28335;
  <D.28337>:
  D.28339 = mono_security_get_mode ();
  if (D.28339 == 1) goto <D.28340>; else goto <D.28341>;
  <D.28340>:
  D.28342 = accessing->image;
  D.28343 = accessed->image;
  D.28344 = mono_security_core_clr_can_access_internals (D.28342, D.28343);
  if (D.28344 == 0) goto <D.28345>; else goto <D.28346>;
  <D.28345>:
  D.28335 = 0;
  return D.28335;
  <D.28346>:
  <D.28341>:
  mono_assembly_load_friends (accessed);
  tmp = accessed->friend_assembly_names;
  goto <D.21209>;
  <D.21208>:
  {
    struct MonoAssemblyName * friend;

    friend = tmp->data;
    D.28347 = friend->name;
    if (D.28347 == 0B) goto <D.28348>; else goto <D.28349>;
    <D.28348>:
    // predicted unlikely by continue predictor.
    goto <D.21207>;
    <D.28349>:
    D.28350 = accessing->aname.name;
    D.28347 = friend->name;
    D.28351 = strcmp (D.28350, D.28347);
    if (D.28351 != 0) goto <D.28352>; else goto <D.28353>;
    <D.28352>:
    // predicted unlikely by continue predictor.
    goto <D.21207>;
    <D.28353>:
    D.28354 = friend->public_key_token[0];
    if (D.28354 != 0) goto <D.28355>; else goto <D.28356>;
    <D.28355>:
    D.28357 = accessing->aname.public_key_token[0];
    if (D.28357 == 0) goto <D.28358>; else goto <D.28359>;
    <D.28358>:
    // predicted unlikely by continue predictor.
    goto <D.21207>;
    <D.28359>:
    D.28360 = &friend->public_key_token;
    D.28361 = &accessing->aname.public_key_token;
    D.28362 = mono_public_tokens_are_equal (D.28360, D.28361);
    if (D.28362 == 0) goto <D.28363>; else goto <D.28364>;
    <D.28363>:
    // predicted unlikely by continue predictor.
    goto <D.21207>;
    <D.28364>:
    <D.28356>:
    D.28335 = 1;
    return D.28335;
  }
  <D.21207>:
  tmp = tmp->next;
  <D.21209>:
  if (tmp != 0B) goto <D.21208>; else goto <D.21210>;
  <D.21210>:
  D.28335 = 0;
  return D.28335;
}


mono_method_can_access_method (struct MonoMethod * method, struct MonoMethod * called)
{
  struct MonoClass * D.28366;
  struct MonoClass * D.28367;
  short unsigned int D.28368;
  int D.28369;
  int D.28370;
  mono_bool D.28375;
  unsigned int D.28376;
  unsigned int D.28377;
  int can;

  D.28366 = method->klass;
  D.28367 = called->klass;
  D.28368 = called->flags;
  D.28369 = (int) D.28368;
  D.28370 = D.28369 & 7;
  can = can_access_member (D.28366, D.28367, 0B, D.28370);
  if (can == 0) goto <D.28371>; else goto <D.28372>;
  <D.28371>:
  {
    struct MonoClass * nested;

    D.28366 = method->klass;
    nested = D.28366->nested_in;
    goto <D.21277>;
    <D.21276>:
    D.28367 = called->klass;
    D.28368 = called->flags;
    D.28369 = (int) D.28368;
    D.28370 = D.28369 & 7;
    can = can_access_member (nested, D.28367, 0B, D.28370);
    if (can != 0) goto <D.28373>; else goto <D.28374>;
    <D.28373>:
    D.28375 = 1;
    return D.28375;
    <D.28374>:
    nested = nested->nested_in;
    <D.21277>:
    if (nested != 0B) goto <D.21276>; else goto <D.21278>;
    <D.21278>:
  }
  <D.28372>:
  D.28368 = called->flags;
  D.28376 = (unsigned int) D.28368;
  D.28377 = D.28376 & 96;
  if (D.28377 == 96) goto <D.28378>; else goto <D.28379>;
  <D.28378>:
  D.28375 = 1;
  return D.28375;
  <D.28379>:
  D.28375 = can;
  return D.28375;
}


__attribute__((visibility ("hidden")))
mono_method_can_access_method_full (struct MonoMethod * method, struct MonoMethod * called, struct MonoClass * context_klass)
{
  short unsigned int D.28381;
  int D.28382;
  int D.28383;
  gboolean D.28389;
  long unsigned int D.28395;
  long unsigned int D.28396;
  struct MonoGenericInst * D.28399;
  int D.28402;
  struct MonoClass * access_class;
  struct MonoClass * member_class;
  int can;

  access_class = method->klass;
  member_class = called->klass;
  D.28381 = called->flags;
  D.28382 = (int) D.28381;
  D.28383 = D.28382 & 7;
  can = can_access_member (access_class, member_class, context_klass, D.28383);
  if (can == 0) goto <D.28384>; else goto <D.28385>;
  <D.28384>:
  {
    struct MonoClass * nested;

    nested = access_class->nested_in;
    goto <D.21290>;
    <D.21289>:
    D.28381 = called->flags;
    D.28382 = (int) D.28381;
    D.28383 = D.28382 & 7;
    can = can_access_member (nested, member_class, context_klass, D.28383);
    if (can != 0) goto <D.21288>; else goto <D.28386>;
    <D.28386>:
    nested = nested->nested_in;
    <D.21290>:
    if (nested != 0B) goto <D.21289>; else goto <D.21288>;
    <D.21288>:
  }
  <D.28385>:
  if (can == 0) goto <D.28387>; else goto <D.28388>;
  <D.28387>:
  D.28389 = 0;
  return D.28389;
  <D.28388>:
  can = can_access_type (access_class, member_class);
  if (can == 0) goto <D.28390>; else goto <D.28391>;
  <D.28390>:
  {
    struct MonoClass * nested;

    nested = access_class->nested_in;
    goto <D.21294>;
    <D.21293>:
    can = can_access_type (nested, member_class);
    if (can != 0) goto <D.21292>; else goto <D.28392>;
    <D.28392>:
    nested = nested->nested_in;
    <D.21294>:
    if (nested != 0B) goto <D.21293>; else goto <D.21292>;
    <D.21292>:
  }
  <D.28391>:
  if (can == 0) goto <D.28393>; else goto <D.28394>;
  <D.28393>:
  D.28389 = 0;
  return D.28389;
  <D.28394>:
  D.28395 = BIT_FIELD_REF <*called, 64, 256>;
  D.28396 = D.28395 & 2251799813685248;
  if (D.28396 != 0) goto <D.28397>; else goto <D.28398>;
  <D.28397>:
  {
    struct MonoMethodInflated * infl;

    infl = called;
    D.28399 = infl->context.method_inst;
    if (D.28399 != 0B) goto <D.28400>; else goto <D.28401>;
    <D.28400>:
    D.28399 = infl->context.method_inst;
    D.28402 = can_access_instantiation (access_class, D.28399);
    if (D.28402 == 0) goto <D.28403>; else goto <D.28404>;
    <D.28403>:
    D.28389 = 0;
    return D.28389;
    <D.28404>:
    <D.28401>:
  }
  <D.28398>:
  D.28389 = 1;
  return D.28389;
}


can_access_type (struct MonoClass * access_klass, struct MonoClass * member_klass)
{
  struct MonoImage * D.28406;
  struct MonoAssembly * D.28407;
  unsigned char D.28410;
  gboolean D.28413;
  struct MonoClass * D.28414;
  long unsigned int D.28417;
  long unsigned int D.28418;
  struct MonoClass * D.28421;
  long unsigned int D.28424;
  long unsigned int D.28425;
  unsigned int D.28428;
  int D.28429;
  unsigned char D.28432;
  struct MonoGenericClass * D.28434;
  struct MonoGenericInst * D.28437;
  int D.28438;
  int D.28443;
  struct MonoClass * D.28445;
  int D.28447;
  struct MonoClass * D.28448;
  int D.28451;
  unsigned int access_level.282;
  unsigned int D.28455;
  struct MonoImage * D.28460;
  struct MonoAssembly * D.28461;
  int iftmp.283;
  struct MonoImage * D.28465;
  struct MonoAssembly * D.28466;
  int D.28467;
  int D.28469;
  int iftmp.284;
  int D.28475;
  int D.28477;
  int access_level;

  D.28406 = access_klass->image;
  D.28407 = D.28406->assembly;
  if (D.28407 != 0B) goto <D.28408>; else goto <D.28409>;
  <D.28408>:
  D.28406 = access_klass->image;
  D.28407 = D.28406->assembly;
  D.28410 = D.28407->corlib_internal;
  if (D.28410 != 0) goto <D.28411>; else goto <D.28412>;
  <D.28411>:
  D.28413 = 1;
  return D.28413;
  <D.28412>:
  <D.28409>:
  D.28414 = access_klass->element_class;
  if (D.28414 != 0B) goto <D.28415>; else goto <D.28416>;
  <D.28415>:
  D.28417 = BIT_FIELD_REF <*access_klass, 64, 256>;
  D.28418 = D.28417 & 576460752303423488;
  if (D.28418 == 0) goto <D.28419>; else goto <D.28420>;
  <D.28419>:
  access_klass = access_klass->element_class;
  <D.28420>:
  <D.28416>:
  D.28421 = member_klass->element_class;
  if (D.28421 != 0B) goto <D.28422>; else goto <D.28423>;
  <D.28422>:
  D.28424 = BIT_FIELD_REF <*member_klass, 64, 256>;
  D.28425 = D.28424 & 576460752303423488;
  if (D.28425 == 0) goto <D.28426>; else goto <D.28427>;
  <D.28426>:
  member_klass = member_klass->element_class;
  <D.28427>:
  <D.28423>:
  D.28428 = member_klass->flags;
  D.28429 = (int) D.28428;
  access_level = D.28429 & 7;
  D.28432 = member_klass->byval_arg.type;
  if (D.28432 == 19) goto <D.28430>; else goto <D.28433>;
  <D.28433>:
  D.28432 = member_klass->byval_arg.type;
  if (D.28432 == 30) goto <D.28430>; else goto <D.28431>;
  <D.28430>:
  D.28413 = 1;
  return D.28413;
  <D.28431>:
  D.28434 = member_klass->generic_class;
  if (D.28434 != 0B) goto <D.28435>; else goto <D.28436>;
  <D.28435>:
  D.28434 = member_klass->generic_class;
  D.28437 = D.28434->context.class_inst;
  D.28438 = can_access_instantiation (access_klass, D.28437);
  if (D.28438 == 0) goto <D.28439>; else goto <D.28440>;
  <D.28439>:
  D.28413 = 0;
  return D.28413;
  <D.28440>:
  <D.28436>:
  D.28443 = is_nesting_type (access_klass, member_klass);
  if (D.28443 != 0) goto <D.28441>; else goto <D.28444>;
  <D.28444>:
  D.28445 = access_klass->nested_in;
  if (D.28445 != 0B) goto <D.28446>; else goto <D.28442>;
  <D.28446>:
  D.28445 = access_klass->nested_in;
  D.28447 = is_nesting_type (D.28445, member_klass);
  if (D.28447 != 0) goto <D.28441>; else goto <D.28442>;
  <D.28441>:
  D.28413 = 1;
  return D.28413;
  <D.28442>:
  D.28448 = member_klass->nested_in;
  if (D.28448 != 0B) goto <D.28449>; else goto <D.28450>;
  <D.28449>:
  D.28448 = member_klass->nested_in;
  D.28451 = can_access_type (access_klass, D.28448);
  if (D.28451 == 0) goto <D.28452>; else goto <D.28453>;
  <D.28452>:
  D.28413 = 0;
  return D.28413;
  <D.28453>:
  <D.28450>:
  access_level.282 = (unsigned int) access_level;
  D.28455 = access_level.282 + 4294967293;
  if (D.28455 <= 4) goto <D.28456>; else goto <D.28457>;
  <D.28456>:
  D.28448 = member_klass->nested_in;
  if (D.28448 == 0B) goto <D.28458>; else goto <D.28459>;
  <D.28458>:
  D.28413 = 0;
  return D.28413;
  <D.28459>:
  <D.28457>:
  switch (access_level) <default: <D.28478>, case 0: <D.21238>, case 1: <D.21239>, case 2: <D.21240>, case 3: <D.21241>, case 4: <D.21242>, case 5: <D.21243>, case 6: <D.21244>, case 7: <D.21245>>
  <D.21238>:
  D.28406 = access_klass->image;
  D.28407 = D.28406->assembly;
  D.28460 = member_klass->image;
  D.28461 = D.28460->assembly;
  D.28413 = can_access_internals (D.28407, D.28461);
  return D.28413;
  <D.21239>:
  D.28413 = 1;
  return D.28413;
  <D.21240>:
  D.28413 = 1;
  return D.28413;
  <D.21241>:
  D.28413 = is_nesting_type (member_klass, access_klass);
  return D.28413;
  <D.21242>:
  D.28448 = member_klass->nested_in;
  D.28413 = mono_class_has_parent_and_ignore_generics (access_klass, D.28448);
  return D.28413;
  <D.21243>:
  D.28406 = access_klass->image;
  D.28407 = D.28406->assembly;
  D.28460 = member_klass->image;
  D.28461 = D.28460->assembly;
  D.28413 = can_access_internals (D.28407, D.28461);
  return D.28413;
  <D.21244>:
  D.28406 = access_klass->image;
  D.28407 = D.28406->assembly;
  D.28448 = member_klass->nested_in;
  D.28465 = D.28448->image;
  D.28466 = D.28465->assembly;
  D.28467 = can_access_internals (D.28407, D.28466);
  if (D.28467 != 0) goto <D.28468>; else goto <D.28463>;
  <D.28468>:
  D.28448 = member_klass->nested_in;
  D.28469 = mono_class_has_parent_and_ignore_generics (access_klass, D.28448);
  if (D.28469 != 0) goto <D.28470>; else goto <D.28463>;
  <D.28470>:
  iftmp.283 = 1;
  goto <D.28464>;
  <D.28463>:
  iftmp.283 = 0;
  <D.28464>:
  D.28413 = iftmp.283;
  return D.28413;
  <D.21245>:
  D.28406 = access_klass->image;
  D.28407 = D.28406->assembly;
  D.28448 = member_klass->nested_in;
  D.28465 = D.28448->image;
  D.28466 = D.28465->assembly;
  D.28475 = can_access_internals (D.28407, D.28466);
  if (D.28475 != 0) goto <D.28472>; else goto <D.28476>;
  <D.28476>:
  D.28448 = member_klass->nested_in;
  D.28477 = mono_class_has_parent_and_ignore_generics (access_klass, D.28448);
  if (D.28477 != 0) goto <D.28472>; else goto <D.28473>;
  <D.28472>:
  iftmp.284 = 1;
  goto <D.28474>;
  <D.28473>:
  iftmp.284 = 0;
  <D.28474>:
  D.28413 = iftmp.284;
  return D.28413;
  <D.28478>:
  D.28413 = 0;
  return D.28413;
}


is_nesting_type (struct MonoClass * outer_klass, struct MonoClass * inner_klass)
{
  gboolean D.28482;

  outer_klass = mono_class_get_generic_type_definition (outer_klass);
  inner_klass = mono_class_get_generic_type_definition (inner_klass);
  <D.21183>:
  if (outer_klass == inner_klass) goto <D.28480>; else goto <D.28481>;
  <D.28480>:
  D.28482 = 1;
  return D.28482;
  <D.28481>:
  inner_klass = inner_klass->nested_in;
  if (inner_klass != 0B) goto <D.21183>; else goto <D.21184>;
  <D.21184>:
  D.28482 = 0;
  return D.28482;
}


can_access_instantiation (struct MonoClass * access_klass, struct MonoGenericInst * ginst)
{
  unsigned char D.28484;
  int D.28485;
  struct MonoClass * D.28486;
  int D.28487;
  gboolean D.28490;
  struct MonoArrayType * D.28491;
  struct MonoClass * D.28492;
  int D.28493;
  struct MonoType * D.28496;
  struct MonoClass * D.28497;
  int D.28498;
  struct MonoClass * D.28501;
  int D.28502;
  <unnamed-unsigned:22> D.28506;
  int D.28507;
  int i;

  i = 0;
  goto <D.21231>;
  <D.21230>:
  {
    struct MonoType * type;

    type = ginst->type_argv[i];
    D.28484 = type->type;
    D.28485 = (int) D.28484;
    switch (D.28485) <default: <D.28505>, case 15: <D.21226>, case 17: <D.21228>, case 18: <D.21227>, case 20: <D.21225>, case 21: <D.21229>, case 29: <D.21223>>
    <D.21223>:
    D.28486 = type->data.klass;
    D.28487 = can_access_type (access_klass, D.28486);
    if (D.28487 == 0) goto <D.28488>; else goto <D.28489>;
    <D.28488>:
    D.28490 = 0;
    return D.28490;
    <D.28489>:
    goto <D.21224>;
    <D.21225>:
    D.28491 = type->data.array;
    D.28492 = D.28491->eklass;
    D.28493 = can_access_type (access_klass, D.28492);
    if (D.28493 == 0) goto <D.28494>; else goto <D.28495>;
    <D.28494>:
    D.28490 = 0;
    return D.28490;
    <D.28495>:
    goto <D.21224>;
    <D.21226>:
    D.28496 = type->data.type;
    D.28497 = mono_class_from_mono_type (D.28496);
    D.28498 = can_access_type (access_klass, D.28497);
    if (D.28498 == 0) goto <D.28499>; else goto <D.28500>;
    <D.28499>:
    D.28490 = 0;
    return D.28490;
    <D.28500>:
    goto <D.21224>;
    <D.21227>:
    <D.21228>:
    <D.21229>:
    D.28501 = mono_class_from_mono_type (type);
    D.28502 = can_access_type (access_klass, D.28501);
    if (D.28502 == 0) goto <D.28503>; else goto <D.28504>;
    <D.28503>:
    D.28490 = 0;
    return D.28490;
    <D.28504>:
    <D.28505>:
    <D.21224>:
  }
  i = i + 1;
  <D.21231>:
  D.28506 = ginst->type_argc;
  D.28507 = (int) D.28506;
  if (D.28507 > i) goto <D.21230>; else goto <D.21232>;
  <D.21232>:
  D.28490 = 1;
  return D.28490;
}


__attribute__((visibility ("hidden")))
mono_method_can_access_field_full (struct MonoMethod * method, struct MonoClassField * field, struct MonoClass * context_klass)
{
  struct MonoType * D.28509;
  short unsigned int D.28510;
  int D.28511;
  int D.28512;
  gboolean D.28518;
  struct MonoClass * access_class;
  struct MonoClass * member_class;
  int can;

  access_class = method->klass;
  member_class = field->parent;
  D.28509 = field->type;
  D.28510 = D.28509->attrs;
  D.28511 = (int) D.28510;
  D.28512 = D.28511 & 7;
  can = can_access_member (access_class, member_class, context_klass, D.28512);
  if (can == 0) goto <D.28513>; else goto <D.28514>;
  <D.28513>:
  {
    struct MonoClass * nested;

    nested = access_class->nested_in;
    goto <D.21307>;
    <D.21306>:
    D.28509 = field->type;
    D.28510 = D.28509->attrs;
    D.28511 = (int) D.28510;
    D.28512 = D.28511 & 7;
    can = can_access_member (nested, member_class, context_klass, D.28512);
    if (can != 0) goto <D.21305>; else goto <D.28515>;
    <D.28515>:
    nested = nested->nested_in;
    <D.21307>:
    if (nested != 0B) goto <D.21306>; else goto <D.21305>;
    <D.21305>:
  }
  <D.28514>:
  if (can == 0) goto <D.28516>; else goto <D.28517>;
  <D.28516>:
  D.28518 = 0;
  return D.28518;
  <D.28517>:
  can = can_access_type (access_class, member_class);
  if (can == 0) goto <D.28519>; else goto <D.28520>;
  <D.28519>:
  {
    struct MonoClass * nested;

    nested = access_class->nested_in;
    goto <D.21311>;
    <D.21310>:
    can = can_access_type (nested, member_class);
    if (can != 0) goto <D.21309>; else goto <D.28521>;
    <D.28521>:
    nested = nested->nested_in;
    <D.21311>:
    if (nested != 0B) goto <D.21310>; else goto <D.21309>;
    <D.21309>:
  }
  <D.28520>:
  if (can == 0) goto <D.28522>; else goto <D.28523>;
  <D.28522>:
  D.28518 = 0;
  return D.28518;
  <D.28523>:
  D.28518 = 1;
  return D.28518;
}


__attribute__((visibility ("hidden")))
mono_class_can_access_class (struct MonoClass * source_class, struct MonoClass * target_class)
{
  gboolean D.28525;

  D.28525 = can_access_type (source_class, target_class);
  return D.28525;
}


mono_type_is_valid_enum_basetype (struct MonoType * type)
{
  unsigned char D.28527;
  int D.28528;
  gboolean D.28529;

  D.28527 = type->type;
  D.28528 = (int) D.28527;
  switch (D.28528) <default: <D.28530>, case 2: <D.21321>, case 3: <D.21324>, case 4: <D.21319>, case 5: <D.21320>, case 6: <D.21322>, case 7: <D.21323>, case 8: <D.21325>, case 9: <D.21326>, case 10: <D.21327>, case 11: <D.21328>, case 24: <D.21329>, case 25: <D.21330>>
  <D.21319>:
  <D.21320>:
  <D.21321>:
  <D.21322>:
  <D.21323>:
  <D.21324>:
  <D.21325>:
  <D.21326>:
  <D.21327>:
  <D.21328>:
  <D.21329>:
  <D.21330>:
  D.28529 = 1;
  return D.28529;
  <D.28530>:
  D.28529 = 0;
  return D.28529;
}


mono_class_is_valid_enum (struct MonoClass * klass)
{
  long unsigned int D.28532;
  long unsigned int D.28533;
  _Bool D.28534;
  long int D.28535;
  long int D.28536;
  struct MonoClass * D.28541;
  const char * D.28543;
  int D.28544;
  const char * D.28546;
  int D.28547;
  gboolean D.28548;
  unsigned int D.28549;
  unsigned int D.28550;
  struct MonoType * D.28553;
  short unsigned int D.28554;
  int D.28555;
  int D.28556;
  int D.28561;
  unsigned int D.28566;
  struct MonoClassField * field;
  void * iter;
  gboolean found_base_field;

  try
    {
      iter = 0B;
      found_base_field = 0;
      D.28532 = BIT_FIELD_REF <*klass, 64, 256>;
      D.28533 = D.28532 & 576460752303423488;
      D.28534 = D.28533 == 0;
      D.28535 = (long int) D.28534;
      D.28536 = __builtin_expect (D.28535, 0);
      if (D.28536 != 0) goto <D.28537>; else goto <D.28538>;
      <D.28537>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "class.c", 9963, "klass->enumtype");
      <D.28538>:
      D.28541 = klass->parent;
      if (D.28541 == 0B) goto <D.28539>; else goto <D.28542>;
      <D.28542>:
      D.28541 = klass->parent;
      D.28543 = D.28541->name;
      D.28544 = strcmp (D.28543, "Enum");
      if (D.28544 != 0) goto <D.28539>; else goto <D.28545>;
      <D.28545>:
      D.28541 = klass->parent;
      D.28546 = D.28541->name_space;
      D.28547 = strcmp (D.28546, "System");
      if (D.28547 != 0) goto <D.28539>; else goto <D.28540>;
      <D.28539>:
      D.28548 = 0;
      return D.28548;
      <D.28540>:
      D.28549 = klass->flags;
      D.28550 = D.28549 & 24;
      if (D.28550 != 0) goto <D.28551>; else goto <D.28552>;
      <D.28551>:
      D.28548 = 0;
      return D.28548;
      <D.28552>:
      goto <D.21338>;
      <D.21337>:
      D.28553 = field->type;
      D.28554 = D.28553->attrs;
      D.28555 = (int) D.28554;
      D.28556 = D.28555 & 16;
      if (D.28556 == 0) goto <D.28557>; else goto <D.28558>;
      <D.28557>:
      if (found_base_field != 0) goto <D.28559>; else goto <D.28560>;
      <D.28559>:
      D.28548 = 0;
      return D.28548;
      <D.28560>:
      found_base_field = 1;
      D.28553 = field->type;
      D.28561 = mono_type_is_valid_enum_basetype (D.28553);
      if (D.28561 == 0) goto <D.28562>; else goto <D.28563>;
      <D.28562>:
      D.28548 = 0;
      return D.28548;
      <D.28563>:
      <D.28558>:
      <D.21338>:
      field = mono_class_get_fields (klass, &iter);
      if (field != 0B) goto <D.21337>; else goto <D.21339>;
      <D.21339>:
      if (found_base_field == 0) goto <D.28564>; else goto <D.28565>;
      <D.28564>:
      D.28548 = 0;
      return D.28548;
      <D.28565>:
      D.28566 = klass->method.count;
      if (D.28566 != 0) goto <D.28567>; else goto <D.28568>;
      <D.28567>:
      D.28548 = 0;
      return D.28548;
      <D.28568>:
      D.28548 = 1;
      return D.28548;
    }
  finally
    {
      iter = {CLOBBER};
    }
}


__attribute__((visibility ("hidden")))
mono_generic_class_is_generic_type_definition (struct MonoGenericClass * gklass)
{
  gboolean D.28571;
  struct MonoGenericInst * D.28572;
  struct MonoClass * D.28573;
  struct MonoGenericContainer * D.28574;
  struct MonoGenericInst * D.28575;
  _Bool D.28576;

  D.28572 = gklass->context.class_inst;
  D.28573 = gklass->container_class;
  D.28574 = D.28573->generic_container;
  D.28575 = D.28574->context.class_inst;
  D.28576 = D.28572 == D.28575;
  D.28571 = (gboolean) D.28576;
  return D.28571;
}


__attribute__((visibility ("hidden")))
mono_class_setup_interface_id (struct MonoClass * class)
{
  unsigned int D.28580;
  unsigned int D.28581;
  unsigned char D.28583;
  short unsigned int D.28585;
  unsigned int D.28588;
  short unsigned int D.28589;

  mono_loader_lock ();
  D.28580 = class->flags;
  D.28581 = D.28580 & 32;
  if (D.28581 != 0) goto <D.28578>; else goto <D.28582>;
  <D.28582>:
  D.28583 = class->byval_arg.type;
  if (D.28583 == 19) goto <D.28578>; else goto <D.28584>;
  <D.28584>:
  D.28583 = class->byval_arg.type;
  if (D.28583 == 30) goto <D.28578>; else goto <D.28579>;
  <D.28578>:
  D.28585 = class->interface_id;
  if (D.28585 == 0) goto <D.28586>; else goto <D.28587>;
  <D.28586>:
  D.28588 = mono_get_unique_iid (class);
  D.28589 = (short unsigned int) D.28588;
  class->interface_id = D.28589;
  <D.28587>:
  <D.28579>:
  mono_loader_unlock ();
}


__attribute__((visibility ("hidden")))
mono_class_alloc_ext (struct MonoClass * klass)
{
  struct MonoClassExt * D.28590;
  void * D.28593;
  unsigned int class_ext_size.285;
  unsigned int D.28595;

  D.28590 = klass->ext;
  if (D.28590 == 0B) goto <D.28591>; else goto <D.28592>;
  <D.28591>:
  D.28593 = mono_class_alloc0 (klass, 64);
  klass->ext = D.28593;
  class_ext_size.285 = class_ext_size;
  D.28595 = class_ext_size.285 + 64;
  class_ext_size = D.28595;
  <D.28592>:
}


__attribute__((visibility ("hidden")))
mono_class_setup_interfaces (struct MonoClass * klass, struct MonoError * error)
{
  long unsigned int D.28596;
  long unsigned int D.28597;
  unsigned char D.28604;
  unsigned char D.28606;
  guint16 iftmp.286;
  struct MonoClass * D.28609;
  struct MonoImage * D.28613;
  short unsigned int D.28614;
  unsigned int D.28615;
  unsigned int D.28616;
  void * D.28617;
  struct MonoClass * D.28618;
  struct MonoType * D.28619;
  struct MonoClass * * D.28620;
  struct MonoClass * D.28621;
  struct MonoClass * D.28622;
  struct MonoClass * * D.28625;
  struct MonoClass * D.28626;
  struct MonoGenericClass * D.28627;
  short unsigned int D.28630;
  unsigned int D.28631;
  unsigned int D.28632;
  int D.28633;
  void * D.28634;
  long unsigned int D.28635;
  long unsigned int D.28636;
  struct MonoClass * * D.28637;
  struct MonoClass * * D.28638;
  struct MonoClass * * D.28639;
  struct MonoClass * D.28640;
  struct MonoGenericContext * D.28641;
  struct MonoClass * D.28642;
  int D.28643;
  gchar * D.28646;
  int D.28647;
  int i;

  mono_error_init (error);
  D.28596 = BIT_FIELD_REF <*klass, 64, 256>;
  D.28597 = D.28596 & 2147483648;
  if (D.28597 != 0) goto <D.28598>; else goto <D.28599>;
  <D.28598>:
  return;
  <D.28599>:
  mono_loader_lock ();
  D.28596 = BIT_FIELD_REF <*klass, 64, 256>;
  D.28597 = D.28596 & 2147483648;
  if (D.28597 != 0) goto <D.28600>; else goto <D.28601>;
  <D.28600>:
  mono_loader_unlock ();
  return;
  <D.28601>:
  D.28604 = klass->rank;
  if (D.28604 == 1) goto <D.28605>; else goto <D.28602>;
  <D.28605>:
  D.28606 = klass->byval_arg.type;
  if (D.28606 != 20) goto <D.28607>; else goto <D.28602>;
  <D.28607>:
  {
    struct MonoType * args[1];

    try
      {
        D.28609 = mono_defaults.generic_ireadonlylist_class;
        if (D.28609 != 0B) goto <D.28610>; else goto <D.28611>;
        <D.28610>:
        iftmp.286 = 2;
        goto <D.28612>;
        <D.28611>:
        iftmp.286 = 1;
        <D.28612>:
        klass->interface_count = iftmp.286;
        D.28613 = klass->image;
        D.28614 = klass->interface_count;
        D.28615 = (unsigned int) D.28614;
        D.28616 = D.28615 * 8;
        D.28617 = mono_image_alloc0 (D.28613, D.28616);
        klass->interfaces = D.28617;
        D.28618 = klass->element_class;
        D.28619 = &D.28618->byval_arg;
        args[0] = D.28619;
        D.28620 = klass->interfaces;
        D.28621 = mono_defaults.generic_ilist_class;
        D.28622 = mono_class_bind_generic_parameters (D.28621, 1, &args, 0);
        *D.28620 = D.28622;
        D.28614 = klass->interface_count;
        if (D.28614 > 1) goto <D.28623>; else goto <D.28624>;
        <D.28623>:
        D.28620 = klass->interfaces;
        D.28625 = D.28620 + 8;
        D.28609 = mono_defaults.generic_ireadonlylist_class;
        D.28626 = mono_class_bind_generic_parameters (D.28609, 1, &args, 0);
        *D.28625 = D.28626;
        <D.28624>:
      }
    finally
      {
        args = {CLOBBER};
      }
  }
  goto <D.28603>;
  <D.28602>:
  D.28627 = klass->generic_class;
  if (D.28627 != 0B) goto <D.28628>; else goto <D.28629>;
  <D.28628>:
  {
    struct MonoClass * gklass;

    D.28627 = klass->generic_class;
    gklass = D.28627->container_class;
    D.28630 = gklass->interface_count;
    klass->interface_count = D.28630;
    D.28614 = klass->interface_count;
    D.28631 = (unsigned int) D.28614;
    D.28632 = D.28631 * 8;
    D.28633 = (int) D.28632;
    D.28634 = mono_class_alloc0 (klass, D.28633);
    klass->interfaces = D.28634;
    i = 0;
    goto <D.21357>;
    <D.21356>:
    D.28620 = klass->interfaces;
    D.28635 = (long unsigned int) i;
    D.28636 = D.28635 * 8;
    D.28637 = D.28620 + D.28636;
    D.28638 = gklass->interfaces;
    D.28635 = (long unsigned int) i;
    D.28636 = D.28635 * 8;
    D.28639 = D.28638 + D.28636;
    D.28640 = *D.28639;
    D.28627 = klass->generic_class;
    D.28641 = mono_generic_class_get_context (D.28627);
    D.28642 = mono_class_inflate_generic_class_checked (D.28640, D.28641, error);
    *D.28637 = D.28642;
    D.28643 = mono_error_ok (error);
    if (D.28643 == 0) goto <D.28644>; else goto <D.28645>;
    <D.28644>:
    D.28646 = monoeg_strdup ("Could not setup the interfaces");
    mono_class_set_failure (klass, 7, D.28646);
    klass->interfaces = 0B;
    return;
    <D.28645>:
    i = i + 1;
    <D.21357>:
    D.28614 = klass->interface_count;
    D.28647 = (int) D.28614;
    if (D.28647 > i) goto <D.21356>; else goto <D.21358>;
    <D.21358>:
  }
  <D.28629>:
  <D.28603>:
  mono_memory_barrier ();
  klass->interfaces_inited = 1;
  mono_loader_unlock ();
}


__attribute__((visibility ("hidden")))
mono_class_get_fields_lazy (struct MonoClass * klass, void * * iter)
{
  struct MonoClassField * D.28651;
  void * D.28652;
  struct MonoClassField * D.28655;
  unsigned int D.28658;
  long unsigned int D.28661;
  long unsigned int D.28662;
  struct MonoClassField * D.28663;
  struct MonoClassField * field;

  if (iter == 0B) goto <D.28649>; else goto <D.28650>;
  <D.28649>:
  D.28651 = 0B;
  return D.28651;
  <D.28650>:
  D.28652 = *iter;
  if (D.28652 == 0B) goto <D.28653>; else goto <D.28654>;
  <D.28653>:
  mono_class_setup_basic_field_info_locking (klass);
  D.28655 = klass->fields;
  if (D.28655 == 0B) goto <D.28656>; else goto <D.28657>;
  <D.28656>:
  D.28651 = 0B;
  return D.28651;
  <D.28657>:
  D.28658 = klass->field.count;
  if (D.28658 != 0) goto <D.28659>; else goto <D.28660>;
  <D.28659>:
  D.28655 = klass->fields;
  *iter = D.28655;
  D.28651 = *iter;
  return D.28651;
  <D.28660>:
  D.28651 = 0B;
  return D.28651;
  <D.28654>:
  field = *iter;
  field = field + 32;
  D.28655 = klass->fields;
  D.28658 = klass->field.count;
  D.28661 = (long unsigned int) D.28658;
  D.28662 = D.28661 * 32;
  D.28663 = D.28655 + D.28662;
  if (D.28663 > field) goto <D.28664>; else goto <D.28665>;
  <D.28664>:
  *iter = field;
  D.28651 = *iter;
  return D.28651;
  <D.28665>:
  D.28651 = 0B;
  return D.28651;
}


mono_class_setup_basic_field_info_locking (struct MonoClass * class)
{
  mono_loader_lock ();
  mono_class_setup_basic_field_info (class);
  mono_loader_unlock ();
}


__attribute__((visibility ("hidden")))
mono_class_full_name (struct MonoClass * klass)
{
  char * D.28667;
  struct MonoType * D.28668;

  D.28668 = &klass->byval_arg;
  D.28667 = mono_type_full_name (D.28668);
  return D.28667;
}