mono_class_from_typeref (struct MonoImage * image, guint32 type_token)
{
  unsigned int D.21698;
  unsigned int D.21699;
  int D.21700;
  const char * D.21703;
  char * D.21704;
  struct MonoClass * D.21705;
  int D.21706;
  unsigned int D.21707;
  unsigned int D.21708;
  unsigned int D.21709;
  unsigned int D.21710;
  int idx.0;
  const char * iftmp.1;
  char D.21717;
  struct MonoAssembly * D.21721;
  struct MonoAssemblyName * D.21722;
  gchar * D.21725;
  unsigned int D.21726;
  unsigned char D.21731;
  unsigned char D.21732;
  struct MonoClassExt * D.21734;
  int D.18480;
  const char * D.21736;
  unsigned int D.21739;
  struct MonoImage * D.21740;
  unsigned int D.21741;
  int D.21742;
  struct MonoTableInfo * D.21743;
  unsigned int D.21744;
  int D.21745;
  struct MonoTableInfo * D.21746;
  int D.18496;
  unsigned int D.21749;
  int D.21750;
  int D.21753;
  unsigned int D.21754;
  unsigned int D.21755;
  <unnamed-unsigned:24> D.21757;
  unsigned int D.21758;
  gchar * D.21761;
  struct MonoAssembly * * D.21764;
  sizetype D.21766;
  sizetype D.21767;
  struct MonoAssembly * * D.21768;
  struct MonoAssembly * D.21769;
  unsigned int D.21770;
  int D.21771;
  _Bool D.21772;
  long int D.21773;
  long int D.21774;
  int iftmp.2;
  struct MonoImage * D.21783;
  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.21698 = type_token & 16777215;
      D.21699 = D.21698 + 4294967295;
      D.21700 = mono_verifier_verify_typeref_row (image, D.21699, &error);
      if (D.21700 == 0) goto <D.21701>; else goto <D.21702>;
      <D.21701>:
      D.21703 = mono_error_get_message (&error);
      D.21704 = image->name;
      mono_trace (16, 2, "Failed to resolve typeref from %s due to \'%s\'", D.21704, D.21703);
      D.21705 = 0B;
      return D.21705;
      <D.21702>:
      D.21698 = type_token & 16777215;
      D.21699 = D.21698 + 4294967295;
      D.21706 = (int) D.21699;
      mono_metadata_decode_row (t, D.21706, &cols, 3);
      D.21707 = cols[1];
      name = mono_metadata_string_heap (image, D.21707);
      D.21708 = cols[2];
      nspace = mono_metadata_string_heap (image, D.21708);
      D.21709 = cols[0];
      idx = D.21709 >> 2;
      D.21709 = cols[0];
      D.21710 = D.21709 & 3;
      switch (D.21710) <default: <D.21756>, case 0: <D.18464>, case 1: <D.18466>, case 2: <D.18501>, case 3: <D.18469>>
      <D.18464>:
      if (idx == 0) goto <D.21711>; else goto <D.21712>;
      <D.21711>:
      monoeg_g_log (0B, 4, "null ResolutionScope not yet handled");
      <D.18465>:
      goto <D.18465>;
      <D.21712>:
      D.21705 = mono_class_from_name (image, nspace, name);
      return D.21705;
      <D.18466>:
      idx.0 = (int) idx;
      module = mono_image_load_module (image, idx.0);
      if (module != 0B) goto <D.21714>; else goto <D.21715>;
      <D.21714>:
      D.21705 = mono_class_from_name (module, nspace, name);
      return D.21705;
      <D.21715>:
      {
        char * msg;
        char * human_name;

        D.21717 = *nspace;
        if (D.21717 != 0) goto <D.21718>; else goto <D.21719>;
        <D.21718>:
        iftmp.1 = ".";
        goto <D.21720>;
        <D.21719>:
        iftmp.1 = "";
        <D.21720>:
        msg = monoeg_g_strdup_printf ("%s%s%s", nspace, iftmp.1, name);
        D.21721 = image->assembly;
        D.21722 = &D.21721->aname;
        human_name = mono_stringify_assembly_name (D.21722);
        mono_loader_set_error_type_load (msg, human_name);
        monoeg_g_free (msg);
        monoeg_g_free (human_name);
        D.21705 = 0B;
        return D.21705;
      }
      <D.18469>:
      {
        struct MonoClass * enclosing;
        struct GList * tmp;

        D.21698 = type_token & 16777215;
        if (D.21698 == idx) goto <D.21723>; else goto <D.21724>;
        <D.21723>:
        D.21704 = image->name;
        D.21725 = monoeg_g_strdup_printf ("Image %s with self-referencing typeref token %08x.", D.21704, type_token);
        mono_loader_set_error_bad_image (D.21725);
        D.21705 = 0B;
        return D.21705;
        <D.21724>:
        D.21726 = idx | 16777216;
        enclosing = mono_class_from_typeref (image, D.21726);
        if (enclosing == 0B) goto <D.21727>; else goto <D.21728>;
        <D.21727>:
        D.21705 = 0B;
        return D.21705;
        <D.21728>:
        D.21731 = BIT_FIELD_REF <*enclosing, 8, 184>;
        D.21732 = D.21731 & 128;
        if (D.21732 != 0) goto <D.21733>; else goto <D.21729>;
        <D.21733>:
        D.21734 = enclosing->ext;
        if (D.21734 != 0B) goto <D.21735>; else goto <D.21729>;
        <D.21735>:
        D.21734 = enclosing->ext;
        tmp = D.21734->nested_classes;
        goto <D.18482>;
        <D.18481>:
        res = tmp->data;
        {
          size_t __s1_len;
          size_t __s2_len;

          D.21736 = res->name;
          D.18480 = __builtin_strcmp (D.21736, name);
        }
        if (D.18480 == 0) goto <D.21737>; else goto <D.21738>;
        <D.21737>:
        D.21705 = res;
        return D.21705;
        <D.21738>:
        tmp = tmp->next;
        <D.18482>:
        if (tmp != 0B) goto <D.18481>; else goto <D.18483>;
        <D.18483>:
        goto <D.21730>;
        <D.21729>:
        {
          int i;

          D.21739 = enclosing->type_token;
          D.21740 = enclosing->image;
          D.21741 = mono_metadata_nesting_typedef (D.21740, D.21739, 1);
          i = (int) D.21741;
          goto <D.18499>;
          <D.18498>:
          {
            guint32 class_nested;
            guint32 string_offset;
            const char * nname;

            D.21742 = i + -1;
            D.21740 = enclosing->image;
            D.21743 = &D.21740->tables[41];
            class_nested = mono_metadata_decode_row_col (D.21743, D.21742, 0);
            D.21744 = class_nested + 4294967295;
            D.21745 = (int) D.21744;
            D.21740 = enclosing->image;
            D.21746 = &D.21740->tables[2];
            string_offset = mono_metadata_decode_row_col (D.21746, D.21745, 1);
            D.21740 = enclosing->image;
            nname = mono_metadata_string_heap (D.21740, string_offset);
            {
              size_t __s1_len;
              size_t __s2_len;

              D.18496 = __builtin_strcmp (nname, name);
            }
            if (D.18496 == 0) goto <D.21747>; else goto <D.21748>;
            <D.21747>:
            {
              struct MonoClass * res;

              D.21749 = class_nested | 33554432;
              D.21740 = enclosing->image;
              res = mono_class_create_from_typedef (D.21740, D.21749, &error);
              D.21750 = mono_error_ok (&error);
              if (D.21750 == 0) goto <D.21751>; else goto <D.21752>;
              <D.21751>:
              mono_loader_set_error_from_mono_error (&error);
              mono_error_cleanup (&error);
              D.21705 = 0B;
              return D.21705;
              <D.21752>:
              D.21705 = res;
              return D.21705;
            }
            <D.21748>:
            D.21753 = i + 1;
            D.21754 = (unsigned int) D.21753;
            D.21739 = enclosing->type_token;
            D.21740 = enclosing->image;
            D.21755 = mono_metadata_nesting_typedef (D.21740, D.21739, D.21754);
            i = (int) D.21755;
          }
          <D.18499>:
          if (i != 0) goto <D.18498>; else goto <D.18500>;
          <D.18500>:
        }
        <D.21730>:
        D.21704 = image->name;
        monoeg_g_log (0B, 16, "TypeRef ResolutionScope not yet handled (%d) for %s.%s in image %s", idx, nspace, name, D.21704);
        D.21705 = 0B;
        return D.21705;
      }
      <D.18501>:
      goto <D.18502>;
      <D.21756>:
      <D.18502>:
      D.21757 = image->tables[35].rows;
      D.21758 = (unsigned int) D.21757;
      if (D.21758 < idx) goto <D.21759>; else goto <D.21760>;
      <D.21759>:
      D.21704 = image->name;
      D.21761 = monoeg_g_strdup_printf ("Image %s with invalid assemblyref token %08x.", D.21704, idx);
      mono_loader_set_error_bad_image (D.21761);
      D.21705 = 0B;
      return D.21705;
      <D.21760>:
      D.21764 = image->references;
      if (D.21764 == 0B) goto <D.21762>; else goto <D.21765>;
      <D.21765>:
      D.21764 = image->references;
      D.21766 = idx + 1073741823;
      D.21767 = D.21766 * 4;
      D.21768 = D.21764 + D.21767;
      D.21769 = *D.21768;
      if (D.21769 == 0B) goto <D.21762>; else goto <D.21763>;
      <D.21762>:
      D.21770 = idx + 4294967295;
      D.21771 = (int) D.21770;
      mono_assembly_load_reference (image, D.21771);
      <D.21763>:
      D.21764 = image->references;
      D.21766 = idx + 1073741823;
      D.21767 = D.21766 * 4;
      D.21768 = D.21764 + D.21767;
      D.21769 = *D.21768;
      D.21772 = D.21769 == 0B;
      D.21773 = (long int) D.21772;
      D.21774 = __builtin_expect (D.21773, 0);
      if (D.21774 != 0) goto <D.21775>; else goto <D.21776>;
      <D.21775>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "class.c", 248, "image->references [idx - 1]");
      <D.21776>:
      D.21764 = image->references;
      D.21766 = idx + 1073741823;
      D.21767 = D.21766 * 4;
      D.21768 = D.21764 + D.21767;
      D.21769 = *D.21768;
      if (D.21769 == 4294967295B) goto <D.21777>; else goto <D.21778>;
      <D.21777>:
      {
        struct MonoAssemblyName aname;
        char * human_name;

        try
          {
            D.21770 = idx + 4294967295;
            D.21771 = (int) D.21770;
            mono_assembly_get_assemblyref (image, D.21771, &aname);
            human_name = mono_stringify_assembly_name (&aname);
            D.21721 = image->assembly;
            if (D.21721 != 0B) goto <D.21780>; else goto <D.21781>;
            <D.21780>:
            D.21721 = image->assembly;
            iftmp.2 = D.21721->ref_only;
            goto <D.21782>;
            <D.21781>:
            iftmp.2 = 0;
            <D.21782>:
            mono_loader_set_error_assembly_load (human_name, iftmp.2);
            monoeg_g_free (human_name);
            D.21705 = 0B;
            return D.21705;
          }
        finally
          {
            aname = {CLOBBER};
          }
      }
      <D.21778>:
      D.21764 = image->references;
      D.21766 = idx + 1073741823;
      D.21767 = D.21766 * 4;
      D.21768 = D.21764 + D.21767;
      D.21769 = *D.21768;
      D.21783 = D.21769->image;
      D.21705 = mono_class_from_name (D.21783, nspace, name);
      return D.21705;
    }
  finally
    {
      error = {CLOBBER};
      cols = {CLOBBER};
    }
}


mono_class_create_from_typedef (struct MonoImage * image, guint32 type_token, struct MonoError * error)
{
  unsigned int D.21789;
  <unnamed-unsigned:24> D.21791;
  unsigned int D.21792;
  struct MonoLoaderError * D.21793;
  _Bool D.21794;
  long int D.21795;
  long int D.21796;
  struct MonoClass * D.21799;
  void * type_token.3;
  struct MonoInternalHashTable * D.21801;
  struct MonoLoaderError * D.21804;
  _Bool D.21805;
  long int D.21806;
  long int D.21807;
  unsigned int D.21810;
  int D.21811;
  unsigned int D.21812;
  unsigned int D.21813;
  unsigned int D.21814;
  unsigned int classes_size.4;
  unsigned int classes_size.5;
  unsigned int D.21817;
  struct MonoGenericContainer * D.21818;
  struct MonoGenericContainer * D.21819;
  unsigned int D.21824;
  unsigned int D.21827;
  gchar * D.21832;
  struct MonoGenericClass * D.21837;
  struct MonoClass * D.21840;
  struct MonoClass * D.21847;
  int D.21848;
  const char * D.21851;
  gchar * D.21852;
  struct MonoLoaderError * D.21853;
  _Bool D.21854;
  long int D.21855;
  long int D.21856;
  unsigned int D.21859;
  unsigned int D.21860;
  struct MonoClass * D.21863;
  unsigned char D.21864;
  unsigned char D.21865;
  int D.21868;
  gchar * D.21871;
  struct MonoClass * * interfaces.6;
  unsigned int icount.7;
  short unsigned int D.21874;
  unsigned int D.21875;
  unsigned int D.21876;
  unsigned int D.21877;
  unsigned int D.21878;
  int tidx.8;
  unsigned int D.21882;
  unsigned int D.21883;
  <unnamed-unsigned:24> D.21885;
  <unnamed-unsigned:24> D.21886;
  unsigned int D.21890;
  unsigned int D.21892;
  unsigned int D.21893;
  unsigned int D.21894;
  unsigned int D.21897;
  unsigned int D.21898;
  int D.21900;
  int D.20324;
  int iftmp.9;
  int D.20323;
  const char[7] * D.21906;
  unsigned char D.21907;
  int D.21908;
  unsigned char D.21909;
  int D.21910;
  _Bool D.21911;
  _Bool D.21912;
  _Bool D.21913;
  const unsigned char * D.21916;
  unsigned char D.21917;
  int D.21918;
  const unsigned char * D.21919;
  unsigned char D.21920;
  int D.21921;
  _Bool D.21922;
  _Bool D.21923;
  const unsigned char * D.21926;
  unsigned char D.21927;
  int D.21928;
  const unsigned char * D.21929;
  unsigned char D.21930;
  int D.21931;
  _Bool D.21932;
  _Bool D.21933;
  const unsigned char * D.21936;
  unsigned char D.21937;
  int D.21938;
  const unsigned char * D.21939;
  unsigned char D.21940;
  int D.21941;
  int D.20333;
  int iftmp.10;
  int D.20332;
  const char[6] * D.21948;
  unsigned char D.21949;
  int D.21950;
  unsigned char D.21951;
  int D.21952;
  _Bool D.21953;
  _Bool D.21954;
  _Bool D.21955;
  const unsigned char * D.21958;
  unsigned char D.21959;
  int D.21960;
  const unsigned char * D.21961;
  unsigned char D.21962;
  int D.21963;
  _Bool D.21964;
  _Bool D.21965;
  const unsigned char * D.21968;
  unsigned char D.21969;
  int D.21970;
  const unsigned char * D.21971;
  unsigned char D.21972;
  int D.21973;
  _Bool D.21974;
  _Bool D.21975;
  const unsigned char * D.21978;
  unsigned char D.21979;
  int D.21980;
  const unsigned char * D.21981;
  unsigned char D.21982;
  int D.21983;
  int D.21987;
  unsigned int D.21988;
  unsigned int D.21989;
  int D.21990;
  unsigned int D.21991;
  _Bool D.21992;
  long int D.21993;
  long int D.21994;
  struct MonoClass * D.22001;
  struct MonoLoaderError * D.22002;
  _Bool D.22003;
  long int D.22004;
  long int D.22005;
  struct MonoClass * D.22008;
  int D.22011;
  gchar * D.22014;
  struct MonoLoaderError * D.22015;
  _Bool D.22016;
  long int D.22017;
  long int D.22018;
  struct MonoImage * D.22021;
  const char * D.22022;
  int D.20343;
  int iftmp.11;
  int D.20342;
  const char[10] * D.22028;
  unsigned char D.22029;
  int D.22030;
  unsigned char D.22031;
  int D.22032;
  _Bool D.22033;
  _Bool D.22034;
  _Bool D.22035;
  const unsigned char * D.22038;
  unsigned char D.22039;
  int D.22040;
  const unsigned char * D.22041;
  unsigned char D.22042;
  int D.22043;
  _Bool D.22044;
  _Bool D.22045;
  const unsigned char * D.22048;
  unsigned char D.22049;
  int D.22050;
  const unsigned char * D.22051;
  unsigned char D.22052;
  int D.22053;
  _Bool D.22054;
  _Bool D.22055;
  const unsigned char * D.22058;
  unsigned char D.22059;
  int D.22060;
  const unsigned char * D.22061;
  unsigned char D.22062;
  int D.22063;
  int D.20352;
  int iftmp.12;
  int D.20351;
  unsigned char D.22070;
  int D.22071;
  _Bool D.22072;
  _Bool D.22073;
  _Bool D.22074;
  const unsigned char * D.22077;
  unsigned char D.22078;
  int D.22079;
  _Bool D.22080;
  _Bool D.22081;
  const unsigned char * D.22084;
  unsigned char D.22085;
  int D.22086;
  _Bool D.22087;
  _Bool D.22088;
  const unsigned char * D.22091;
  unsigned char D.22092;
  int D.22093;
  int D.22097;
  int iftmp.13;
  int D.20370;
  int iftmp.14;
  int D.20369;
  const char[3] * D.22107;
  unsigned char D.22108;
  int D.22109;
  unsigned char D.22110;
  int D.22111;
  _Bool D.22112;
  _Bool D.22113;
  _Bool D.22114;
  const unsigned char * D.22117;
  unsigned char D.22118;
  int D.22119;
  const unsigned char * D.22120;
  unsigned char D.22121;
  int D.22122;
  _Bool D.22123;
  _Bool D.22124;
  const unsigned char * D.22127;
  unsigned char D.22128;
  int D.22129;
  const unsigned char * D.22130;
  unsigned char D.22131;
  int D.22132;
  _Bool D.22133;
  _Bool D.22134;
  const unsigned char * D.22137;
  unsigned char D.22138;
  int D.22139;
  const unsigned char * D.22140;
  unsigned char D.22141;
  int D.22142;
  const char * D.22144;
  int D.20379;
  int iftmp.15;
  int D.20378;
  const char[4] * D.22149;
  unsigned char D.22150;
  int D.22151;
  unsigned char D.22152;
  int D.22153;
  _Bool D.22154;
  _Bool D.22155;
  _Bool D.22156;
  const unsigned char * D.22159;
  unsigned char D.22160;
  int D.22161;
  const unsigned char * D.22162;
  unsigned char D.22163;
  int D.22164;
  _Bool D.22165;
  _Bool D.22166;
  const unsigned char * D.22169;
  unsigned char D.22170;
  int D.22171;
  const unsigned char * D.22172;
  unsigned char D.22173;
  int D.22174;
  _Bool D.22175;
  _Bool D.22176;
  const unsigned char * D.22179;
  unsigned char D.22180;
  int D.22181;
  const unsigned char * D.22182;
  unsigned char D.22183;
  int D.22184;
  int D.20388;
  int iftmp.16;
  int D.20387;
  const char[3] * D.22190;
  unsigned char D.22191;
  int D.22192;
  unsigned char D.22193;
  int D.22194;
  _Bool D.22195;
  _Bool D.22196;
  _Bool D.22197;
  const unsigned char * D.22200;
  unsigned char D.22201;
  int D.22202;
  const unsigned char * D.22203;
  unsigned char D.22204;
  int D.22205;
  _Bool D.22206;
  _Bool D.22207;
  const unsigned char * D.22210;
  unsigned char D.22211;
  int D.22212;
  const unsigned char * D.22213;
  unsigned char D.22214;
  int D.22215;
  _Bool D.22216;
  _Bool D.22217;
  const unsigned char * D.22220;
  unsigned char D.22221;
  int D.22222;
  const unsigned char * D.22223;
  unsigned char D.22224;
  int D.22225;
  int D.20397;
  int iftmp.17;
  int D.20396;
  const char[3] * D.22231;
  unsigned char D.22232;
  int D.22233;
  unsigned char D.22234;
  int D.22235;
  _Bool D.22236;
  _Bool D.22237;
  _Bool D.22238;
  const unsigned char * D.22241;
  unsigned char D.22242;
  int D.22243;
  const unsigned char * D.22244;
  unsigned char D.22245;
  int D.22246;
  _Bool D.22247;
  _Bool D.22248;
  const unsigned char * D.22251;
  unsigned char D.22252;
  int D.22253;
  const unsigned char * D.22254;
  unsigned char D.22255;
  int D.22256;
  _Bool D.22257;
  _Bool D.22258;
  const unsigned char * D.22261;
  unsigned char D.22262;
  int D.22263;
  const unsigned char * D.22264;
  unsigned char D.22265;
  int D.22266;
  int D.20406;
  int iftmp.18;
  int D.20405;
  const char[4] * D.22272;
  unsigned char D.22273;
  int D.22274;
  unsigned char D.22275;
  int D.22276;
  _Bool D.22277;
  _Bool D.22278;
  _Bool D.22279;
  const unsigned char * D.22282;
  unsigned char D.22283;
  int D.22284;
  const unsigned char * D.22285;
  unsigned char D.22286;
  int D.22287;
  _Bool D.22288;
  _Bool D.22289;
  const unsigned char * D.22292;
  unsigned char D.22293;
  int D.22294;
  const unsigned char * D.22295;
  unsigned char D.22296;
  int D.22297;
  _Bool D.22298;
  _Bool D.22299;
  const unsigned char * D.22302;
  unsigned char D.22303;
  int D.22304;
  const unsigned char * D.22305;
  unsigned char D.22306;
  int D.22307;
  int D.20415;
  int iftmp.19;
  int D.20414;
  const char[3] * D.22313;
  unsigned char D.22314;
  int D.22315;
  unsigned char D.22316;
  int D.22317;
  _Bool D.22318;
  _Bool D.22319;
  _Bool D.22320;
  const unsigned char * D.22323;
  unsigned char D.22324;
  int D.22325;
  const unsigned char * D.22326;
  unsigned char D.22327;
  int D.22328;
  _Bool D.22329;
  _Bool D.22330;
  const unsigned char * D.22333;
  unsigned char D.22334;
  int D.22335;
  const unsigned char * D.22336;
  unsigned char D.22337;
  int D.22338;
  _Bool D.22339;
  _Bool D.22340;
  const unsigned char * D.22343;
  unsigned char D.22344;
  int D.22345;
  const unsigned char * D.22346;
  unsigned char D.22347;
  int D.22348;
  int D.20424;
  int iftmp.20;
  int D.20423;
  const char[3] * D.22354;
  unsigned char D.22355;
  int D.22356;
  unsigned char D.22357;
  int D.22358;
  _Bool D.22359;
  _Bool D.22360;
  _Bool D.22361;
  const unsigned char * D.22364;
  unsigned char D.22365;
  int D.22366;
  const unsigned char * D.22367;
  unsigned char D.22368;
  int D.22369;
  _Bool D.22370;
  _Bool D.22371;
  const unsigned char * D.22374;
  unsigned char D.22375;
  int D.22376;
  const unsigned char * D.22377;
  unsigned char D.22378;
  int D.22379;
  _Bool D.22380;
  _Bool D.22381;
  const unsigned char * D.22384;
  unsigned char D.22385;
  int D.22386;
  const unsigned char * D.22387;
  unsigned char D.22388;
  int D.22389;
  int D.20433;
  int iftmp.21;
  int D.20432;
  const char[4] * D.22395;
  unsigned char D.22396;
  int D.22397;
  unsigned char D.22398;
  int D.22399;
  _Bool D.22400;
  _Bool D.22401;
  _Bool D.22402;
  const unsigned char * D.22405;
  unsigned char D.22406;
  int D.22407;
  const unsigned char * D.22408;
  unsigned char D.22409;
  int D.22410;
  _Bool D.22411;
  _Bool D.22412;
  const unsigned char * D.22415;
  unsigned char D.22416;
  int D.22417;
  const unsigned char * D.22418;
  unsigned char D.22419;
  int D.22420;
  _Bool D.22421;
  _Bool D.22422;
  const unsigned char * D.22425;
  unsigned char D.22426;
  int D.22427;
  const unsigned char * D.22428;
  unsigned char D.22429;
  int D.22430;
  int D.20442;
  int iftmp.22;
  int D.20441;
  const char[4] * D.22436;
  unsigned char D.22437;
  int D.22438;
  unsigned char D.22439;
  int D.22440;
  _Bool D.22441;
  _Bool D.22442;
  _Bool D.22443;
  const unsigned char * D.22446;
  unsigned char D.22447;
  int D.22448;
  const unsigned char * D.22449;
  unsigned char D.22450;
  int D.22451;
  _Bool D.22452;
  _Bool D.22453;
  const unsigned char * D.22456;
  unsigned char D.22457;
  int D.22458;
  const unsigned char * D.22459;
  unsigned char D.22460;
  int D.22461;
  _Bool D.22462;
  _Bool D.22463;
  const unsigned char * D.22466;
  unsigned char D.22467;
  int D.22468;
  const unsigned char * D.22469;
  unsigned char D.22470;
  int D.22471;
  int D.20451;
  int iftmp.23;
  int D.20450;
  const char[5] * D.22477;
  unsigned char D.22478;
  int D.22479;
  unsigned char D.22480;
  int D.22481;
  _Bool D.22482;
  _Bool D.22483;
  _Bool D.22484;
  const unsigned char * D.22487;
  unsigned char D.22488;
  int D.22489;
  const unsigned char * D.22490;
  unsigned char D.22491;
  int D.22492;
  _Bool D.22493;
  _Bool D.22494;
  const unsigned char * D.22497;
  unsigned char D.22498;
  int D.22499;
  const unsigned char * D.22500;
  unsigned char D.22501;
  int D.22502;
  _Bool D.22503;
  _Bool D.22504;
  const unsigned char * D.22507;
  unsigned char D.22508;
  int D.22509;
  const unsigned char * D.22510;
  unsigned char D.22511;
  int D.22512;
  unsigned char D.22514;
  <unnamed-unsigned:1> D.22515;
  struct MonoLoaderError * D.22516;
  _Bool D.22517;
  long int D.22518;
  long int D.22519;
  struct MonoLoaderError * D.22522;
  _Bool D.22523;
  long int D.22524;
  long int D.22525;
  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.21789 = type_token >> 24;
      if (D.21789 != 2) goto <D.21787>; else goto <D.21790>;
      <D.21790>:
      D.21791 = tt->rows;
      D.21792 = (unsigned int) D.21791;
      if (D.21792 < tidx) goto <D.21787>; else goto <D.21788>;
      <D.21787>:
      mono_error_set_bad_image (error, image, "Invalid typedef token %x", type_token);
      D.21793 = mono_loader_get_last_error ();
      D.21794 = D.21793 != 0B;
      D.21795 = (long int) D.21794;
      D.21796 = __builtin_expect (D.21795, 0);
      if (D.21796 != 0) goto <D.21797>; else goto <D.21798>;
      <D.21797>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "class.c", 5589, "!mono_loader_get_last_error ()");
      <D.21798>:
      D.21799 = 0B;
      return D.21799;
      <D.21788>:
      mono_loader_lock ();
      type_token.3 = (void *) type_token;
      D.21801 = &image->class_cache;
      class = mono_internal_hash_table_lookup (D.21801, type_token.3);
      if (class != 0B) goto <D.21802>; else goto <D.21803>;
      <D.21802>:
      mono_loader_unlock ();
      D.21804 = mono_loader_get_last_error ();
      D.21805 = D.21804 != 0B;
      D.21806 = (long int) D.21805;
      D.21807 = __builtin_expect (D.21806, 0);
      if (D.21807 != 0) goto <D.21808>; else goto <D.21809>;
      <D.21808>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "class.c", 5597, "!mono_loader_get_last_error ()");
      <D.21809>:
      D.21799 = class;
      return D.21799;
      <D.21803>:
      D.21810 = tidx + 4294967295;
      D.21811 = (int) D.21810;
      mono_metadata_decode_row (tt, D.21811, &cols, 6);
      D.21812 = cols[1];
      name = mono_metadata_string_heap (image, D.21812);
      D.21813 = cols[2];
      nspace = mono_metadata_string_heap (image, D.21813);
      class = mono_image_alloc0 (image, 164);
      class->name = name;
      class->name_space = nspace;
      mono_profiler_class_event (class, 0);
      class->image = image;
      class->type_token = type_token;
      D.21814 = cols[0];
      class->flags = D.21814;
      type_token.3 = (void *) type_token;
      D.21801 = &image->class_cache;
      mono_internal_hash_table_insert (D.21801, type_token.3, class);
      classes_size.4 = classes_size;
      classes_size.5 = classes_size.4 + 164;
      classes_size = classes_size.5;
      D.21817 = class->type_token;
      D.21818 = mono_metadata_load_generic_params (image, D.21817, 0B);
      class->generic_container = D.21818;
      D.21819 = class->generic_container;
      if (D.21819 != 0B) goto <D.21820>; else goto <D.21821>;
      <D.21820>:
      class->is_generic = 1;
      D.21819 = class->generic_container;
      D.21819->owner.klass = class;
      D.21819 = class->generic_container;
      context = &D.21819->context;
      <D.21821>:
      D.21819 = class->generic_container;
      if (D.21819 != 0B) goto <D.21822>; else goto <D.21823>;
      <D.21822>:
      enable_gclass_recording ();
      <D.21823>:
      D.21824 = cols[3];
      if (D.21824 != 0) goto <D.21825>; else goto <D.21826>;
      <D.21825>:
      {
        struct MonoClass * tmp;
        guint32 parent_token;

        D.21824 = cols[3];
        parent_token = mono_metadata_token_from_dor (D.21824);
        D.21827 = parent_token >> 24;
        if (D.21827 == 27) goto <D.21828>; else goto <D.21829>;
        <D.21828>:
        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.21829>:
        parent = mono_class_get_full (image, parent_token, context);
        if (parent == 0B) goto <D.21830>; else goto <D.21831>;
        <D.21830>:
        D.21832 = monoeg_g_strdup_printf ("Could not load parent, token is %x", parent_token);
        mono_class_set_failure_from_loader_error (class, error, D.21832);
        goto parent_failure;
        <D.21831>:
        tmp = parent;
        goto <D.20314>;
        <D.20313>:
        if (tmp == class) goto <D.21833>; else goto <D.21834>;
        <D.21833>:
        mono_class_set_failure_and_error (class, error, "Cycle found while resolving parent");
        goto parent_failure;
        <D.21834>:
        D.21819 = class->generic_container;
        if (D.21819 != 0B) goto <D.21835>; else goto <D.21836>;
        <D.21835>:
        D.21837 = tmp->generic_class;
        if (D.21837 != 0B) goto <D.21838>; else goto <D.21839>;
        <D.21838>:
        D.21837 = tmp->generic_class;
        D.21840 = D.21837->container_class;
        if (D.21840 == class) goto <D.21841>; else goto <D.21842>;
        <D.21841>:
        mono_class_set_failure_and_error (class, error, "Parent extends generic instance of this type");
        goto parent_failure;
        <D.21842>:
        <D.21839>:
        <D.21836>:
        tmp = tmp->parent;
        <D.20314>:
        if (tmp != 0B) goto <D.20313>; else goto <D.20315>;
        <D.20315>:
      }
      <D.21826>:
      mono_class_setup_parent (class, parent);
      mono_class_setup_mono_type (class);
      D.21819 = class->generic_container;
      if (D.21819 != 0B) goto <D.21843>; else goto <D.21844>;
      <D.21843>:
      disable_gclass_recording (fix_gclass_incomplete_instantiation, class);
      <D.21844>:
      nesting_tokeen = mono_metadata_nested_in_typedef (image, type_token);
      if (nesting_tokeen != 0) goto <D.21845>; else goto <D.21846>;
      <D.21845>:
      D.21847 = mono_class_create_from_typedef (image, nesting_tokeen, error);
      class->nested_in = D.21847;
      D.21848 = mono_error_ok (error);
      if (D.21848 == 0) goto <D.21849>; else goto <D.21850>;
      <D.21849>:
      D.21851 = mono_error_get_message (error);
      D.21852 = monoeg_strdup (D.21851);
      mono_class_set_failure (class, 7, D.21852);
      mono_loader_unlock ();
      mono_profiler_class_loaded (class, 1);
      D.21853 = mono_loader_get_last_error ();
      D.21854 = D.21853 != 0B;
      D.21855 = (long int) D.21854;
      D.21856 = __builtin_expect (D.21855, 0);
      if (D.21856 != 0) goto <D.21857>; else goto <D.21858>;
      <D.21857>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "class.c", 5684, "!mono_loader_get_last_error ()");
      <D.21858>:
      D.21799 = 0B;
      return D.21799;
      <D.21850>:
      <D.21846>:
      D.21859 = class->flags;
      D.21860 = D.21859 & 196608;
      if (D.21860 == 65536) goto <D.21861>; else goto <D.21862>;
      <D.21861>:
      class->unicode = 1;
      <D.21862>:
      class->element_class = class;
      D.21863 = class->element_class;
      class->cast_class = D.21863;
      D.21864 = BIT_FIELD_REF <*class, 8, 160>;
      D.21865 = D.21864 & 16;
      if (D.21865 == 0) goto <D.21866>; else goto <D.21867>;
      <D.21866>:
      D.21868 = mono_metadata_interfaces_from_typedef_full (image, type_token, &interfaces, &icount, 0, context);
      if (D.21868 == 0) goto <D.21869>; else goto <D.21870>;
      <D.21869>:
      D.21871 = monoeg_strdup ("Could not load interfaces");
      mono_class_set_failure_from_loader_error (class, error, D.21871);
      mono_loader_unlock ();
      mono_profiler_class_loaded (class, 1);
      D.21799 = 0B;
      return D.21799;
      <D.21870>:
      interfaces.6 = interfaces;
      class->interfaces = interfaces.6;
      icount.7 = icount;
      D.21874 = (short unsigned int) icount.7;
      class->interface_count = D.21874;
      class->interfaces_inited = 1;
      <D.21867>:
      D.21875 = cols[4];
      D.21876 = D.21875 + 4294967295;
      class->field.first = D.21876;
      D.21877 = cols[5];
      D.21878 = D.21877 + 4294967295;
      class->method.first = D.21878;
      D.21791 = tt->rows;
      D.21792 = (unsigned int) D.21791;
      if (D.21792 > tidx) goto <D.21879>; else goto <D.21880>;
      <D.21879>:
      tidx.8 = (int) tidx;
      mono_metadata_decode_row (tt, tidx.8, &cols_next, 6);
      D.21882 = cols_next[4];
      field_last = D.21882 + 4294967295;
      D.21883 = cols_next[5];
      method_last = D.21883 + 4294967295;
      goto <D.21884>;
      <D.21880>:
      D.21885 = image->tables[4].rows;
      field_last = (guint32) D.21885;
      D.21886 = image->tables[6].rows;
      method_last = (guint32) D.21886;
      <D.21884>:
      D.21875 = cols[4];
      if (D.21875 != 0) goto <D.21889>; else goto <D.21887>;
      <D.21889>:
      D.21875 = cols[4];
      D.21885 = image->tables[4].rows;
      D.21890 = (unsigned int) D.21885;
      if (D.21875 <= D.21890) goto <D.21891>; else goto <D.21887>;
      <D.21891>:
      D.21892 = class->field.first;
      D.21893 = field_last - D.21892;
      class->field.count = D.21893;
      goto <D.21888>;
      <D.21887>:
      class->field.count = 0;
      <D.21888>:
      D.21877 = cols[5];
      D.21886 = image->tables[6].rows;
      D.21894 = (unsigned int) D.21886;
      if (D.21877 <= D.21894) goto <D.21895>; else goto <D.21896>;
      <D.21895>:
      D.21897 = class->method.first;
      D.21898 = method_last - D.21897;
      class->method.count = D.21898;
      goto <D.21899>;
      <D.21896>:
      class->method.count = 0;
      <D.21899>:
      D.21900 = mono_is_corlib_image (image);
      if (D.21900 != 0) goto <D.21901>; else goto <D.21902>;
      <D.21901>:
      {
        size_t __s1_len;
        size_t __s2_len;

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

          __s2 = nspace;
          D.21906 = "System";
          D.21907 = MEM[(const unsigned char *)D.21906];
          D.21908 = (int) D.21907;
          D.21909 = *__s2;
          D.21910 = (int) D.21909;
          __result = D.21908 - D.21910;
          {
            D.21911 = __s2_len != 0;
            D.21912 = __result == 0;
            D.21913 = D.21911 & D.21912;
            if (D.21913 != 0) goto <D.21914>; else goto <D.21915>;
            <D.21914>:
            D.21916 = &MEM[(void *)"System" + 1B];
            D.21917 = *D.21916;
            D.21918 = (int) D.21917;
            D.21919 = __s2 + 1;
            D.21920 = *D.21919;
            D.21921 = (int) D.21920;
            __result = D.21918 - D.21921;
            D.21922 = __s2_len > 1;
            D.21912 = __result == 0;
            D.21923 = D.21922 & D.21912;
            if (D.21923 != 0) goto <D.21924>; else goto <D.21925>;
            <D.21924>:
            D.21926 = &MEM[(void *)"System" + 2B];
            D.21927 = *D.21926;
            D.21928 = (int) D.21927;
            D.21929 = __s2 + 2;
            D.21930 = *D.21929;
            D.21931 = (int) D.21930;
            __result = D.21928 - D.21931;
            D.21932 = __s2_len > 2;
            D.21912 = __result == 0;
            D.21933 = D.21932 & D.21912;
            if (D.21933 != 0) goto <D.21934>; else goto <D.21935>;
            <D.21934>:
            D.21936 = &MEM[(void *)"System" + 3B];
            D.21937 = *D.21936;
            D.21938 = (int) D.21937;
            D.21939 = __s2 + 3;
            D.21940 = *D.21939;
            D.21941 = (int) D.21940;
            __result = D.21938 - D.21941;
            <D.21935>:
            <D.21925>:
            <D.21915>:
          }
          D.20323 = __result;
        }
        iftmp.9 = -D.20323;
        goto <D.21942>;
        <D.21905>:
        iftmp.9 = __builtin_strcmp (nspace, "System");
        <D.21942>:
        D.20324 = iftmp.9;
      }
      if (D.20324 == 0) goto <D.21943>; else goto <D.21944>;
      <D.21943>:
      {
        size_t __s1_len;
        size_t __s2_len;

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

          __s2 = name;
          D.21948 = "Array";
          D.21949 = MEM[(const unsigned char *)D.21948];
          D.21950 = (int) D.21949;
          D.21951 = *__s2;
          D.21952 = (int) D.21951;
          __result = D.21950 - D.21952;
          {
            D.21953 = __s2_len != 0;
            D.21954 = __result == 0;
            D.21955 = D.21953 & D.21954;
            if (D.21955 != 0) goto <D.21956>; else goto <D.21957>;
            <D.21956>:
            D.21958 = &MEM[(void *)"Array" + 1B];
            D.21959 = *D.21958;
            D.21960 = (int) D.21959;
            D.21961 = __s2 + 1;
            D.21962 = *D.21961;
            D.21963 = (int) D.21962;
            __result = D.21960 - D.21963;
            D.21964 = __s2_len > 1;
            D.21954 = __result == 0;
            D.21965 = D.21964 & D.21954;
            if (D.21965 != 0) goto <D.21966>; else goto <D.21967>;
            <D.21966>:
            D.21968 = &MEM[(void *)"Array" + 2B];
            D.21969 = *D.21968;
            D.21970 = (int) D.21969;
            D.21971 = __s2 + 2;
            D.21972 = *D.21971;
            D.21973 = (int) D.21972;
            __result = D.21970 - D.21973;
            D.21974 = __s2_len > 2;
            D.21954 = __result == 0;
            D.21975 = D.21974 & D.21954;
            if (D.21975 != 0) goto <D.21976>; else goto <D.21977>;
            <D.21976>:
            D.21978 = &MEM[(void *)"Array" + 3B];
            D.21979 = *D.21978;
            D.21980 = (int) D.21979;
            D.21981 = __s2 + 3;
            D.21982 = *D.21981;
            D.21983 = (int) D.21982;
            __result = D.21980 - D.21983;
            <D.21977>:
            <D.21967>:
            <D.21957>:
          }
          D.20332 = __result;
        }
        iftmp.10 = -D.20332;
        goto <D.21984>;
        <D.21947>:
        iftmp.10 = __builtin_strcmp (name, "Array");
        <D.21984>:
        D.20333 = iftmp.10;
      }
      if (D.20333 == 0) goto <D.21985>; else goto <D.21986>;
      <D.21985>:
      D.21987 = class->instance_size;
      D.21988 = (unsigned int) D.21987;
      D.21989 = D.21988 + 8;
      D.21990 = (int) D.21989;
      class->instance_size = D.21990;
      D.21991 = class->field.count;
      D.21992 = D.21991 != 0;
      D.21993 = (long int) D.21992;
      D.21994 = __builtin_expect (D.21993, 0);
      if (D.21994 != 0) goto <D.21995>; else goto <D.21996>;
      <D.21995>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "class.c", 5744, "class->field.count == 0");
      <D.21996>:
      <D.21986>:
      <D.21944>:
      <D.21902>:
      D.21864 = BIT_FIELD_REF <*class, 8, 160>;
      D.21865 = D.21864 & 16;
      if (D.21865 != 0) goto <D.21997>; else goto <D.21998>;
      <D.21997>:
      {
        struct MonoType * enum_basetype;

        enum_basetype = mono_class_find_enum_basetype (class);
        if (enum_basetype == 0B) goto <D.21999>; else goto <D.22000>;
        <D.21999>:
        D.22001 = mono_defaults.int32_class;
        class->element_class = D.22001;
        D.21863 = class->element_class;
        class->cast_class = D.21863;
        mono_class_set_failure_and_error (class, error, "Could not enum basetype");
        mono_loader_unlock ();
        mono_profiler_class_loaded (class, 1);
        D.22002 = mono_loader_get_last_error ();
        D.22003 = D.22002 != 0B;
        D.22004 = (long int) D.22003;
        D.22005 = __builtin_expect (D.22004, 0);
        if (D.22005 != 0) goto <D.22006>; else goto <D.22007>;
        <D.22006>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "class.c", 5755, "!mono_loader_get_last_error ()");
        <D.22007>:
        D.21799 = 0B;
        return D.21799;
        <D.22000>:
        D.22008 = mono_class_from_mono_type (enum_basetype);
        class->element_class = D.22008;
        D.21863 = class->element_class;
        class->cast_class = D.21863;
      }
      <D.21998>:
      D.21819 = class->generic_container;
      if (D.21819 != 0B) goto <D.22009>; else goto <D.22010>;
      <D.22009>:
      D.21819 = class->generic_container;
      D.22011 = mono_metadata_load_generic_param_constraints_full (image, type_token, D.21819);
      if (D.22011 == 0) goto <D.22012>; else goto <D.22013>;
      <D.22012>:
      D.22014 = monoeg_strdup ("Could not load generic parameter constraints");
      mono_class_set_failure_from_loader_error (class, error, D.22014);
      mono_loader_unlock ();
      mono_profiler_class_loaded (class, 1);
      D.22015 = mono_loader_get_last_error ();
      D.22016 = D.22015 != 0B;
      D.22017 = (long int) D.22016;
      D.22018 = __builtin_expect (D.22017, 0);
      if (D.22018 != 0) goto <D.22019>; else goto <D.22020>;
      <D.22019>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "class.c", 5770, "!mono_loader_get_last_error ()");
      <D.22020>:
      D.21799 = 0B;
      return D.21799;
      <D.22013>:
      <D.22010>:
      D.22021 = class->image;
      D.22022 = D.22021->assembly_name;
      if (D.22022 != 0B) goto <D.22023>; else goto <D.22024>;
      <D.22023>:
      {
        size_t __s1_len;
        size_t __s2_len;

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

          D.22021 = class->image;
          __s2 = D.22021->assembly_name;
          D.22028 = "Mono.Simd";
          D.22029 = MEM[(const unsigned char *)D.22028];
          D.22030 = (int) D.22029;
          D.22031 = *__s2;
          D.22032 = (int) D.22031;
          __result = D.22030 - D.22032;
          {
            D.22033 = __s2_len != 0;
            D.22034 = __result == 0;
            D.22035 = D.22033 & D.22034;
            if (D.22035 != 0) goto <D.22036>; else goto <D.22037>;
            <D.22036>:
            D.22038 = &MEM[(void *)"Mono.Simd" + 1B];
            D.22039 = *D.22038;
            D.22040 = (int) D.22039;
            D.22041 = __s2 + 1;
            D.22042 = *D.22041;
            D.22043 = (int) D.22042;
            __result = D.22040 - D.22043;
            D.22044 = __s2_len > 1;
            D.22034 = __result == 0;
            D.22045 = D.22044 & D.22034;
            if (D.22045 != 0) goto <D.22046>; else goto <D.22047>;
            <D.22046>:
            D.22048 = &MEM[(void *)"Mono.Simd" + 2B];
            D.22049 = *D.22048;
            D.22050 = (int) D.22049;
            D.22051 = __s2 + 2;
            D.22052 = *D.22051;
            D.22053 = (int) D.22052;
            __result = D.22050 - D.22053;
            D.22054 = __s2_len > 2;
            D.22034 = __result == 0;
            D.22055 = D.22054 & D.22034;
            if (D.22055 != 0) goto <D.22056>; else goto <D.22057>;
            <D.22056>:
            D.22058 = &MEM[(void *)"Mono.Simd" + 3B];
            D.22059 = *D.22058;
            D.22060 = (int) D.22059;
            D.22061 = __s2 + 3;
            D.22062 = *D.22061;
            D.22063 = (int) D.22062;
            __result = D.22060 - D.22063;
            <D.22057>:
            <D.22047>:
            <D.22037>:
          }
          D.20342 = __result;
        }
        iftmp.11 = -D.20342;
        goto <D.22064>;
        <D.22027>:
        D.22021 = class->image;
        D.22022 = D.22021->assembly_name;
        iftmp.11 = __builtin_strcmp (D.22022, "Mono.Simd");
        <D.22064>:
        D.20343 = iftmp.11;
      }
      if (D.20343 == 0) goto <D.22065>; else goto <D.22066>;
      <D.22065>:
      {
        size_t __s1_len;
        size_t __s2_len;

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

          __s2 = nspace;
          D.22028 = "Mono.Simd";
          D.22029 = MEM[(const unsigned char *)D.22028];
          D.22030 = (int) D.22029;
          D.22070 = *__s2;
          D.22071 = (int) D.22070;
          __result = D.22030 - D.22071;
          {
            D.22072 = __s2_len != 0;
            D.22073 = __result == 0;
            D.22074 = D.22072 & D.22073;
            if (D.22074 != 0) goto <D.22075>; else goto <D.22076>;
            <D.22075>:
            D.22038 = &MEM[(void *)"Mono.Simd" + 1B];
            D.22039 = *D.22038;
            D.22040 = (int) D.22039;
            D.22077 = __s2 + 1;
            D.22078 = *D.22077;
            D.22079 = (int) D.22078;
            __result = D.22040 - D.22079;
            D.22080 = __s2_len > 1;
            D.22073 = __result == 0;
            D.22081 = D.22080 & D.22073;
            if (D.22081 != 0) goto <D.22082>; else goto <D.22083>;
            <D.22082>:
            D.22048 = &MEM[(void *)"Mono.Simd" + 2B];
            D.22049 = *D.22048;
            D.22050 = (int) D.22049;
            D.22084 = __s2 + 2;
            D.22085 = *D.22084;
            D.22086 = (int) D.22085;
            __result = D.22050 - D.22086;
            D.22087 = __s2_len > 2;
            D.22073 = __result == 0;
            D.22088 = D.22087 & D.22073;
            if (D.22088 != 0) goto <D.22089>; else goto <D.22090>;
            <D.22089>:
            D.22058 = &MEM[(void *)"Mono.Simd" + 3B];
            D.22059 = *D.22058;
            D.22060 = (int) D.22059;
            D.22091 = __s2 + 3;
            D.22092 = *D.22091;
            D.22093 = (int) D.22092;
            __result = D.22060 - D.22093;
            <D.22090>:
            <D.22083>:
            <D.22076>:
          }
          D.20351 = __result;
        }
        iftmp.12 = -D.20351;
        goto <D.22094>;
        <D.22069>:
        iftmp.12 = __builtin_strcmp (nspace, "Mono.Simd");
        <D.22094>:
        D.20352 = iftmp.12;
      }
      if (D.20352 == 0) goto <D.22095>; else goto <D.22096>;
      <D.22095>:
      D.22097 = strncmp (name, "Vector", 6);
      if (D.22097 == 0) goto <D.22098>; else goto <D.22099>;
      <D.22098>:
      {
        size_t __s1_len;
        size_t __s2_len;

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

          __s2 = name + 6;
          D.22107 = "2d";
          D.22108 = MEM[(const unsigned char *)D.22107];
          D.22109 = (int) D.22108;
          D.22110 = *__s2;
          D.22111 = (int) D.22110;
          __result = D.22109 - D.22111;
          {
            D.22112 = __s2_len != 0;
            D.22113 = __result == 0;
            D.22114 = D.22112 & D.22113;
            if (D.22114 != 0) goto <D.22115>; else goto <D.22116>;
            <D.22115>:
            D.22117 = &MEM[(void *)"2d" + 1B];
            D.22118 = *D.22117;
            D.22119 = (int) D.22118;
            D.22120 = __s2 + 1;
            D.22121 = *D.22120;
            D.22122 = (int) D.22121;
            __result = D.22119 - D.22122;
            D.22123 = __s2_len > 1;
            D.22113 = __result == 0;
            D.22124 = D.22123 & D.22113;
            if (D.22124 != 0) goto <D.22125>; else goto <D.22126>;
            <D.22125>:
            D.22127 = &MEM[(void *)"2d" + 2B];
            D.22128 = *D.22127;
            D.22129 = (int) D.22128;
            D.22130 = __s2 + 2;
            D.22131 = *D.22130;
            D.22132 = (int) D.22131;
            __result = D.22129 - D.22132;
            D.22133 = __s2_len > 2;
            D.22113 = __result == 0;
            D.22134 = D.22133 & D.22113;
            if (D.22134 != 0) goto <D.22135>; else goto <D.22136>;
            <D.22135>:
            D.22137 = &MEM[(void *)"2d" + 3B];
            D.22138 = *D.22137;
            D.22139 = (int) D.22138;
            D.22140 = __s2 + 3;
            D.22141 = *D.22140;
            D.22142 = (int) D.22141;
            __result = D.22139 - D.22142;
            <D.22136>:
            <D.22126>:
            <D.22116>:
          }
          D.20369 = __result;
        }
        iftmp.14 = -D.20369;
        goto <D.22143>;
        <D.22106>:
        D.22144 = name + 6;
        iftmp.14 = __builtin_strcmp (D.22144, "2d");
        <D.22143>:
        D.20370 = iftmp.14;
      }
      if (D.20370 == 0) goto <D.22101>; else goto <D.22145>;
      <D.22145>:
      {
        size_t __s1_len;
        size_t __s2_len;

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

          __s2 = name + 6;
          D.22149 = "2ul";
          D.22150 = MEM[(const unsigned char *)D.22149];
          D.22151 = (int) D.22150;
          D.22152 = *__s2;
          D.22153 = (int) D.22152;
          __result = D.22151 - D.22153;
          {
            D.22154 = __s2_len != 0;
            D.22155 = __result == 0;
            D.22156 = D.22154 & D.22155;
            if (D.22156 != 0) goto <D.22157>; else goto <D.22158>;
            <D.22157>:
            D.22159 = &MEM[(void *)"2ul" + 1B];
            D.22160 = *D.22159;
            D.22161 = (int) D.22160;
            D.22162 = __s2 + 1;
            D.22163 = *D.22162;
            D.22164 = (int) D.22163;
            __result = D.22161 - D.22164;
            D.22165 = __s2_len > 1;
            D.22155 = __result == 0;
            D.22166 = D.22165 & D.22155;
            if (D.22166 != 0) goto <D.22167>; else goto <D.22168>;
            <D.22167>:
            D.22169 = &MEM[(void *)"2ul" + 2B];
            D.22170 = *D.22169;
            D.22171 = (int) D.22170;
            D.22172 = __s2 + 2;
            D.22173 = *D.22172;
            D.22174 = (int) D.22173;
            __result = D.22171 - D.22174;
            D.22175 = __s2_len > 2;
            D.22155 = __result == 0;
            D.22176 = D.22175 & D.22155;
            if (D.22176 != 0) goto <D.22177>; else goto <D.22178>;
            <D.22177>:
            D.22179 = &MEM[(void *)"2ul" + 3B];
            D.22180 = *D.22179;
            D.22181 = (int) D.22180;
            D.22182 = __s2 + 3;
            D.22183 = *D.22182;
            D.22184 = (int) D.22183;
            __result = D.22181 - D.22184;
            <D.22178>:
            <D.22168>:
            <D.22158>:
          }
          D.20378 = __result;
        }
        iftmp.15 = -D.20378;
        goto <D.22185>;
        <D.22148>:
        D.22144 = name + 6;
        iftmp.15 = __builtin_strcmp (D.22144, "2ul");
        <D.22185>:
        D.20379 = iftmp.15;
      }
      if (D.20379 == 0) goto <D.22101>; else goto <D.22186>;
      <D.22186>:
      {
        size_t __s1_len;
        size_t __s2_len;

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

          __s2 = name + 6;
          D.22190 = "2l";
          D.22191 = MEM[(const unsigned char *)D.22190];
          D.22192 = (int) D.22191;
          D.22193 = *__s2;
          D.22194 = (int) D.22193;
          __result = D.22192 - D.22194;
          {
            D.22195 = __s2_len != 0;
            D.22196 = __result == 0;
            D.22197 = D.22195 & D.22196;
            if (D.22197 != 0) goto <D.22198>; else goto <D.22199>;
            <D.22198>:
            D.22200 = &MEM[(void *)"2l" + 1B];
            D.22201 = *D.22200;
            D.22202 = (int) D.22201;
            D.22203 = __s2 + 1;
            D.22204 = *D.22203;
            D.22205 = (int) D.22204;
            __result = D.22202 - D.22205;
            D.22206 = __s2_len > 1;
            D.22196 = __result == 0;
            D.22207 = D.22206 & D.22196;
            if (D.22207 != 0) goto <D.22208>; else goto <D.22209>;
            <D.22208>:
            D.22210 = &MEM[(void *)"2l" + 2B];
            D.22211 = *D.22210;
            D.22212 = (int) D.22211;
            D.22213 = __s2 + 2;
            D.22214 = *D.22213;
            D.22215 = (int) D.22214;
            __result = D.22212 - D.22215;
            D.22216 = __s2_len > 2;
            D.22196 = __result == 0;
            D.22217 = D.22216 & D.22196;
            if (D.22217 != 0) goto <D.22218>; else goto <D.22219>;
            <D.22218>:
            D.22220 = &MEM[(void *)"2l" + 3B];
            D.22221 = *D.22220;
            D.22222 = (int) D.22221;
            D.22223 = __s2 + 3;
            D.22224 = *D.22223;
            D.22225 = (int) D.22224;
            __result = D.22222 - D.22225;
            <D.22219>:
            <D.22209>:
            <D.22199>:
          }
          D.20387 = __result;
        }
        iftmp.16 = -D.20387;
        goto <D.22226>;
        <D.22189>:
        D.22144 = name + 6;
        iftmp.16 = __builtin_strcmp (D.22144, "2l");
        <D.22226>:
        D.20388 = iftmp.16;
      }
      if (D.20388 == 0) goto <D.22101>; else goto <D.22227>;
      <D.22227>:
      {
        size_t __s1_len;
        size_t __s2_len;

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

          __s2 = name + 6;
          D.22231 = "4f";
          D.22232 = MEM[(const unsigned char *)D.22231];
          D.22233 = (int) D.22232;
          D.22234 = *__s2;
          D.22235 = (int) D.22234;
          __result = D.22233 - D.22235;
          {
            D.22236 = __s2_len != 0;
            D.22237 = __result == 0;
            D.22238 = D.22236 & D.22237;
            if (D.22238 != 0) goto <D.22239>; else goto <D.22240>;
            <D.22239>:
            D.22241 = &MEM[(void *)"4f" + 1B];
            D.22242 = *D.22241;
            D.22243 = (int) D.22242;
            D.22244 = __s2 + 1;
            D.22245 = *D.22244;
            D.22246 = (int) D.22245;
            __result = D.22243 - D.22246;
            D.22247 = __s2_len > 1;
            D.22237 = __result == 0;
            D.22248 = D.22247 & D.22237;
            if (D.22248 != 0) goto <D.22249>; else goto <D.22250>;
            <D.22249>:
            D.22251 = &MEM[(void *)"4f" + 2B];
            D.22252 = *D.22251;
            D.22253 = (int) D.22252;
            D.22254 = __s2 + 2;
            D.22255 = *D.22254;
            D.22256 = (int) D.22255;
            __result = D.22253 - D.22256;
            D.22257 = __s2_len > 2;
            D.22237 = __result == 0;
            D.22258 = D.22257 & D.22237;
            if (D.22258 != 0) goto <D.22259>; else goto <D.22260>;
            <D.22259>:
            D.22261 = &MEM[(void *)"4f" + 3B];
            D.22262 = *D.22261;
            D.22263 = (int) D.22262;
            D.22264 = __s2 + 3;
            D.22265 = *D.22264;
            D.22266 = (int) D.22265;
            __result = D.22263 - D.22266;
            <D.22260>:
            <D.22250>:
            <D.22240>:
          }
          D.20396 = __result;
        }
        iftmp.17 = -D.20396;
        goto <D.22267>;
        <D.22230>:
        D.22144 = name + 6;
        iftmp.17 = __builtin_strcmp (D.22144, "4f");
        <D.22267>:
        D.20397 = iftmp.17;
      }
      if (D.20397 == 0) goto <D.22101>; else goto <D.22268>;
      <D.22268>:
      {
        size_t __s1_len;
        size_t __s2_len;

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

          __s2 = name + 6;
          D.22272 = "4ui";
          D.22273 = MEM[(const unsigned char *)D.22272];
          D.22274 = (int) D.22273;
          D.22275 = *__s2;
          D.22276 = (int) D.22275;
          __result = D.22274 - D.22276;
          {
            D.22277 = __s2_len != 0;
            D.22278 = __result == 0;
            D.22279 = D.22277 & D.22278;
            if (D.22279 != 0) goto <D.22280>; else goto <D.22281>;
            <D.22280>:
            D.22282 = &MEM[(void *)"4ui" + 1B];
            D.22283 = *D.22282;
            D.22284 = (int) D.22283;
            D.22285 = __s2 + 1;
            D.22286 = *D.22285;
            D.22287 = (int) D.22286;
            __result = D.22284 - D.22287;
            D.22288 = __s2_len > 1;
            D.22278 = __result == 0;
            D.22289 = D.22288 & D.22278;
            if (D.22289 != 0) goto <D.22290>; else goto <D.22291>;
            <D.22290>:
            D.22292 = &MEM[(void *)"4ui" + 2B];
            D.22293 = *D.22292;
            D.22294 = (int) D.22293;
            D.22295 = __s2 + 2;
            D.22296 = *D.22295;
            D.22297 = (int) D.22296;
            __result = D.22294 - D.22297;
            D.22298 = __s2_len > 2;
            D.22278 = __result == 0;
            D.22299 = D.22298 & D.22278;
            if (D.22299 != 0) goto <D.22300>; else goto <D.22301>;
            <D.22300>:
            D.22302 = &MEM[(void *)"4ui" + 3B];
            D.22303 = *D.22302;
            D.22304 = (int) D.22303;
            D.22305 = __s2 + 3;
            D.22306 = *D.22305;
            D.22307 = (int) D.22306;
            __result = D.22304 - D.22307;
            <D.22301>:
            <D.22291>:
            <D.22281>:
          }
          D.20405 = __result;
        }
        iftmp.18 = -D.20405;
        goto <D.22308>;
        <D.22271>:
        D.22144 = name + 6;
        iftmp.18 = __builtin_strcmp (D.22144, "4ui");
        <D.22308>:
        D.20406 = iftmp.18;
      }
      if (D.20406 == 0) goto <D.22101>; else goto <D.22309>;
      <D.22309>:
      {
        size_t __s1_len;
        size_t __s2_len;

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

          __s2 = name + 6;
          D.22313 = "4i";
          D.22314 = MEM[(const unsigned char *)D.22313];
          D.22315 = (int) D.22314;
          D.22316 = *__s2;
          D.22317 = (int) D.22316;
          __result = D.22315 - D.22317;
          {
            D.22318 = __s2_len != 0;
            D.22319 = __result == 0;
            D.22320 = D.22318 & D.22319;
            if (D.22320 != 0) goto <D.22321>; else goto <D.22322>;
            <D.22321>:
            D.22323 = &MEM[(void *)"4i" + 1B];
            D.22324 = *D.22323;
            D.22325 = (int) D.22324;
            D.22326 = __s2 + 1;
            D.22327 = *D.22326;
            D.22328 = (int) D.22327;
            __result = D.22325 - D.22328;
            D.22329 = __s2_len > 1;
            D.22319 = __result == 0;
            D.22330 = D.22329 & D.22319;
            if (D.22330 != 0) goto <D.22331>; else goto <D.22332>;
            <D.22331>:
            D.22333 = &MEM[(void *)"4i" + 2B];
            D.22334 = *D.22333;
            D.22335 = (int) D.22334;
            D.22336 = __s2 + 2;
            D.22337 = *D.22336;
            D.22338 = (int) D.22337;
            __result = D.22335 - D.22338;
            D.22339 = __s2_len > 2;
            D.22319 = __result == 0;
            D.22340 = D.22339 & D.22319;
            if (D.22340 != 0) goto <D.22341>; else goto <D.22342>;
            <D.22341>:
            D.22343 = &MEM[(void *)"4i" + 3B];
            D.22344 = *D.22343;
            D.22345 = (int) D.22344;
            D.22346 = __s2 + 3;
            D.22347 = *D.22346;
            D.22348 = (int) D.22347;
            __result = D.22345 - D.22348;
            <D.22342>:
            <D.22332>:
            <D.22322>:
          }
          D.20414 = __result;
        }
        iftmp.19 = -D.20414;
        goto <D.22349>;
        <D.22312>:
        D.22144 = name + 6;
        iftmp.19 = __builtin_strcmp (D.22144, "4i");
        <D.22349>:
        D.20415 = iftmp.19;
      }
      if (D.20415 == 0) goto <D.22101>; else goto <D.22350>;
      <D.22350>:
      {
        size_t __s1_len;
        size_t __s2_len;

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

          __s2 = name + 6;
          D.22354 = "8s";
          D.22355 = MEM[(const unsigned char *)D.22354];
          D.22356 = (int) D.22355;
          D.22357 = *__s2;
          D.22358 = (int) D.22357;
          __result = D.22356 - D.22358;
          {
            D.22359 = __s2_len != 0;
            D.22360 = __result == 0;
            D.22361 = D.22359 & D.22360;
            if (D.22361 != 0) goto <D.22362>; else goto <D.22363>;
            <D.22362>:
            D.22364 = &MEM[(void *)"8s" + 1B];
            D.22365 = *D.22364;
            D.22366 = (int) D.22365;
            D.22367 = __s2 + 1;
            D.22368 = *D.22367;
            D.22369 = (int) D.22368;
            __result = D.22366 - D.22369;
            D.22370 = __s2_len > 1;
            D.22360 = __result == 0;
            D.22371 = D.22370 & D.22360;
            if (D.22371 != 0) goto <D.22372>; else goto <D.22373>;
            <D.22372>:
            D.22374 = &MEM[(void *)"8s" + 2B];
            D.22375 = *D.22374;
            D.22376 = (int) D.22375;
            D.22377 = __s2 + 2;
            D.22378 = *D.22377;
            D.22379 = (int) D.22378;
            __result = D.22376 - D.22379;
            D.22380 = __s2_len > 2;
            D.22360 = __result == 0;
            D.22381 = D.22380 & D.22360;
            if (D.22381 != 0) goto <D.22382>; else goto <D.22383>;
            <D.22382>:
            D.22384 = &MEM[(void *)"8s" + 3B];
            D.22385 = *D.22384;
            D.22386 = (int) D.22385;
            D.22387 = __s2 + 3;
            D.22388 = *D.22387;
            D.22389 = (int) D.22388;
            __result = D.22386 - D.22389;
            <D.22383>:
            <D.22373>:
            <D.22363>:
          }
          D.20423 = __result;
        }
        iftmp.20 = -D.20423;
        goto <D.22390>;
        <D.22353>:
        D.22144 = name + 6;
        iftmp.20 = __builtin_strcmp (D.22144, "8s");
        <D.22390>:
        D.20424 = iftmp.20;
      }
      if (D.20424 == 0) goto <D.22101>; else goto <D.22391>;
      <D.22391>:
      {
        size_t __s1_len;
        size_t __s2_len;

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

          __s2 = name + 6;
          D.22395 = "8us";
          D.22396 = MEM[(const unsigned char *)D.22395];
          D.22397 = (int) D.22396;
          D.22398 = *__s2;
          D.22399 = (int) D.22398;
          __result = D.22397 - D.22399;
          {
            D.22400 = __s2_len != 0;
            D.22401 = __result == 0;
            D.22402 = D.22400 & D.22401;
            if (D.22402 != 0) goto <D.22403>; else goto <D.22404>;
            <D.22403>:
            D.22405 = &MEM[(void *)"8us" + 1B];
            D.22406 = *D.22405;
            D.22407 = (int) D.22406;
            D.22408 = __s2 + 1;
            D.22409 = *D.22408;
            D.22410 = (int) D.22409;
            __result = D.22407 - D.22410;
            D.22411 = __s2_len > 1;
            D.22401 = __result == 0;
            D.22412 = D.22411 & D.22401;
            if (D.22412 != 0) goto <D.22413>; else goto <D.22414>;
            <D.22413>:
            D.22415 = &MEM[(void *)"8us" + 2B];
            D.22416 = *D.22415;
            D.22417 = (int) D.22416;
            D.22418 = __s2 + 2;
            D.22419 = *D.22418;
            D.22420 = (int) D.22419;
            __result = D.22417 - D.22420;
            D.22421 = __s2_len > 2;
            D.22401 = __result == 0;
            D.22422 = D.22421 & D.22401;
            if (D.22422 != 0) goto <D.22423>; else goto <D.22424>;
            <D.22423>:
            D.22425 = &MEM[(void *)"8us" + 3B];
            D.22426 = *D.22425;
            D.22427 = (int) D.22426;
            D.22428 = __s2 + 3;
            D.22429 = *D.22428;
            D.22430 = (int) D.22429;
            __result = D.22427 - D.22430;
            <D.22424>:
            <D.22414>:
            <D.22404>:
          }
          D.20432 = __result;
        }
        iftmp.21 = -D.20432;
        goto <D.22431>;
        <D.22394>:
        D.22144 = name + 6;
        iftmp.21 = __builtin_strcmp (D.22144, "8us");
        <D.22431>:
        D.20433 = iftmp.21;
      }
      if (D.20433 == 0) goto <D.22101>; else goto <D.22432>;
      <D.22432>:
      {
        size_t __s1_len;
        size_t __s2_len;

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

          __s2 = name + 6;
          D.22436 = "16b";
          D.22437 = MEM[(const unsigned char *)D.22436];
          D.22438 = (int) D.22437;
          D.22439 = *__s2;
          D.22440 = (int) D.22439;
          __result = D.22438 - D.22440;
          {
            D.22441 = __s2_len != 0;
            D.22442 = __result == 0;
            D.22443 = D.22441 & D.22442;
            if (D.22443 != 0) goto <D.22444>; else goto <D.22445>;
            <D.22444>:
            D.22446 = &MEM[(void *)"16b" + 1B];
            D.22447 = *D.22446;
            D.22448 = (int) D.22447;
            D.22449 = __s2 + 1;
            D.22450 = *D.22449;
            D.22451 = (int) D.22450;
            __result = D.22448 - D.22451;
            D.22452 = __s2_len > 1;
            D.22442 = __result == 0;
            D.22453 = D.22452 & D.22442;
            if (D.22453 != 0) goto <D.22454>; else goto <D.22455>;
            <D.22454>:
            D.22456 = &MEM[(void *)"16b" + 2B];
            D.22457 = *D.22456;
            D.22458 = (int) D.22457;
            D.22459 = __s2 + 2;
            D.22460 = *D.22459;
            D.22461 = (int) D.22460;
            __result = D.22458 - D.22461;
            D.22462 = __s2_len > 2;
            D.22442 = __result == 0;
            D.22463 = D.22462 & D.22442;
            if (D.22463 != 0) goto <D.22464>; else goto <D.22465>;
            <D.22464>:
            D.22466 = &MEM[(void *)"16b" + 3B];
            D.22467 = *D.22466;
            D.22468 = (int) D.22467;
            D.22469 = __s2 + 3;
            D.22470 = *D.22469;
            D.22471 = (int) D.22470;
            __result = D.22468 - D.22471;
            <D.22465>:
            <D.22455>:
            <D.22445>:
          }
          D.20441 = __result;
        }
        iftmp.22 = -D.20441;
        goto <D.22472>;
        <D.22435>:
        D.22144 = name + 6;
        iftmp.22 = __builtin_strcmp (D.22144, "16b");
        <D.22472>:
        D.20442 = iftmp.22;
      }
      if (D.20442 == 0) goto <D.22101>; else goto <D.22473>;
      <D.22473>:
      {
        size_t __s1_len;
        size_t __s2_len;

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

          __s2 = name + 6;
          D.22477 = "16sb";
          D.22478 = MEM[(const unsigned char *)D.22477];
          D.22479 = (int) D.22478;
          D.22480 = *__s2;
          D.22481 = (int) D.22480;
          __result = D.22479 - D.22481;
          {
            D.22482 = __s2_len != 0;
            D.22483 = __result == 0;
            D.22484 = D.22482 & D.22483;
            if (D.22484 != 0) goto <D.22485>; else goto <D.22486>;
            <D.22485>:
            D.22487 = &MEM[(void *)"16sb" + 1B];
            D.22488 = *D.22487;
            D.22489 = (int) D.22488;
            D.22490 = __s2 + 1;
            D.22491 = *D.22490;
            D.22492 = (int) D.22491;
            __result = D.22489 - D.22492;
            D.22493 = __s2_len > 1;
            D.22483 = __result == 0;
            D.22494 = D.22493 & D.22483;
            if (D.22494 != 0) goto <D.22495>; else goto <D.22496>;
            <D.22495>:
            D.22497 = &MEM[(void *)"16sb" + 2B];
            D.22498 = *D.22497;
            D.22499 = (int) D.22498;
            D.22500 = __s2 + 2;
            D.22501 = *D.22500;
            D.22502 = (int) D.22501;
            __result = D.22499 - D.22502;
            D.22503 = __s2_len > 2;
            D.22483 = __result == 0;
            D.22504 = D.22503 & D.22483;
            if (D.22504 != 0) goto <D.22505>; else goto <D.22506>;
            <D.22505>:
            D.22507 = &MEM[(void *)"16sb" + 3B];
            D.22508 = *D.22507;
            D.22509 = (int) D.22508;
            D.22510 = __s2 + 3;
            D.22511 = *D.22510;
            D.22512 = (int) D.22511;
            __result = D.22509 - D.22512;
            <D.22506>:
            <D.22496>:
            <D.22486>:
          }
          D.20450 = __result;
        }
        iftmp.23 = -D.20450;
        goto <D.22513>;
        <D.22476>:
        D.22144 = name + 6;
        iftmp.23 = __builtin_strcmp (D.22144, "16sb");
        <D.22513>:
        D.20451 = iftmp.23;
      }
      if (D.20451 == 0) goto <D.22101>; else goto <D.22102>;
      <D.22101>:
      iftmp.13 = 1;
      goto <D.22103>;
      <D.22102>:
      iftmp.13 = 0;
      <D.22103>:
      D.22514 = (unsigned char) iftmp.13;
      D.22515 = (<unnamed-unsigned:1>) D.22514;
      class->simd_type = D.22515;
      <D.22099>:
      <D.22096>:
      <D.22066>:
      <D.22024>:
      mono_loader_unlock ();
      mono_profiler_class_loaded (class, 0);
      D.22516 = mono_loader_get_last_error ();
      D.22517 = D.22516 != 0B;
      D.22518 = (long int) D.22517;
      D.22519 = __builtin_expect (D.22518, 0);
      if (D.22519 != 0) goto <D.22520>; else goto <D.22521>;
      <D.22520>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "class.c", 5782, "!mono_loader_get_last_error ()");
      <D.22521>:
      D.21799 = class;
      return D.21799;
      parent_failure:
      mono_class_setup_mono_type (class);
      mono_loader_unlock ();
      mono_profiler_class_loaded (class, 1);
      D.22522 = mono_loader_get_last_error ();
      D.22523 = D.22522 != 0B;
      D.22524 = (long int) D.22523;
      D.22525 = __builtin_expect (D.22524, 0);
      if (D.22525 != 0) goto <D.22526>; else goto <D.22527>;
      <D.22526>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "class.c", 5790, "!mono_loader_get_last_error ()");
      <D.22527>:
      D.21799 = 0B;
      return D.21799;
    }
  finally
    {
      cols = {CLOBBER};
      cols_next = {CLOBBER};
      icount = {CLOBBER};
      interfaces = {CLOBBER};
    }
}


fix_gclass_incomplete_instantiation (struct MonoClass * gclass, void * user_data)
{
  struct MonoGenericClass * D.22530;
  struct MonoClass * D.22531;
  gboolean D.22534;
  struct MonoClass * D.22535;
  struct MonoClass * D.22538;
  struct MonoClass * gtd;

  gtd = user_data;
  D.22530 = gclass->generic_class;
  D.22531 = D.22530->container_class;
  if (D.22531 != gtd) goto <D.22532>; else goto <D.22533>;
  <D.22532>:
  D.22534 = 0;
  return D.22534;
  <D.22533>:
  D.22535 = gtd->parent;
  if (D.22535 != 0B) goto <D.22536>; else goto <D.22537>;
  <D.22536>:
  D.22538 = gclass->parent;
  if (D.22538 == 0B) goto <D.22539>; else goto <D.22540>;
  <D.22539>:
  mono_generic_class_setup_parent (gclass, gtd);
  <D.22540>:
  <D.22537>:
  D.22534 = 1;
  return D.22534;
}


mono_generic_class_setup_parent (struct MonoClass * klass, struct MonoClass * gtd)
{
  struct MonoClass * D.22542;
  struct MonoGenericContext * D.22545;
  struct MonoClass * D.22546;
  int D.22547;
  struct MonoClass * D.22550;
  struct MonoClass * D.22551;
  unsigned char D.22554;
  unsigned char D.22555;
  struct MonoClass * D.22558;
  struct MonoClass * D.22559;

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

    try
      {
        gclass = klass->generic_class;
        D.22545 = mono_generic_class_get_context (gclass);
        D.22542 = gtd->parent;
        D.22546 = mono_class_inflate_generic_class_checked (D.22542, D.22545, &error);
        klass->parent = D.22546;
        D.22547 = mono_error_ok (&error);
        if (D.22547 == 0) goto <D.22548>; else goto <D.22549>;
        <D.22548>:
        D.22550 = mono_defaults.object_class;
        klass->parent = D.22550;
        mono_class_set_failure (klass, 7, 0B);
        mono_error_cleanup (&error);
        <D.22549>:
      }
    finally
      {
        error = {CLOBBER};
      }
  }
  <D.22544>:
  D.22551 = klass->parent;
  if (D.22551 != 0B) goto <D.22552>; else goto <D.22553>;
  <D.22552>:
  D.22551 = klass->parent;
  mono_class_setup_parent (klass, D.22551);
  <D.22553>:
  D.22554 = BIT_FIELD_REF <*klass, 8, 160>;
  D.22555 = D.22554 & 16;
  if (D.22555 != 0) goto <D.22556>; else goto <D.22557>;
  <D.22556>:
  D.22558 = gtd->cast_class;
  klass->cast_class = D.22558;
  D.22559 = gtd->element_class;
  klass->element_class = D.22559;
  <D.22557>:
}


mono_class_inflate_generic_class_checked (struct MonoClass * gklass, struct MonoGenericContext * context, struct MonoError * error)
{
  struct MonoType * D.22560;
  int D.22561;
  struct MonoClass * D.22564;
  struct MonoClass * res;
  struct MonoType * inflated;

  D.22560 = &gklass->byval_arg;
  inflated = mono_class_inflate_generic_type_checked (D.22560, context, error);
  D.22561 = mono_error_ok (error);
  if (D.22561 == 0) goto <D.22562>; else goto <D.22563>;
  <D.22562>:
  D.22564 = 0B;
  return D.22564;
  <D.22563>:
  res = mono_class_from_mono_type (inflated);
  mono_metadata_free_type (inflated);
  D.22564 = res;
  return D.22564;
}


enable_gclass_recording ()
{
  int record_gclass_instantiation.24;
  int record_gclass_instantiation.25;

  record_gclass_instantiation.24 = record_gclass_instantiation;
  record_gclass_instantiation.25 = record_gclass_instantiation.24 + 1;
  record_gclass_instantiation = record_gclass_instantiation.25;
}


disable_gclass_recording (gboolean (*gclass_record_func) (struct MonoClass *, void *) func, void * user_data)
{
  int record_gclass_instantiation.26;
  _Bool D.22569;
  long int D.22570;
  long int D.22571;
  int record_gclass_instantiation.27;
  void * D.22575;
  int D.22576;
  struct GSList * D.22579;
  struct GSList * D.22581;
  struct GSList * gclass_recorded_list.28;
  struct GSList * * head;

  head = &gclass_recorded_list;
  record_gclass_instantiation.26 = record_gclass_instantiation;
  D.22569 = record_gclass_instantiation.26 <= 0;
  D.22570 = (long int) D.22569;
  D.22571 = __builtin_expect (D.22570, 0);
  if (D.22571 != 0) goto <D.22572>; else goto <D.22573>;
  <D.22572>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "class.c", 120, "record_gclass_instantiation > 0");
  <D.22573>:
  record_gclass_instantiation.26 = record_gclass_instantiation;
  record_gclass_instantiation.27 = record_gclass_instantiation.26 + -1;
  record_gclass_instantiation = record_gclass_instantiation.27;
  goto <D.18450>;
  <D.18449>:
  {
    struct GSList * node;

    node = *head;
    D.22575 = node->data;
    D.22576 = func (D.22575, user_data);
    if (D.22576 != 0) goto <D.22577>; else goto <D.22578>;
    <D.22577>:
    D.22579 = node->next;
    *head = D.22579;
    monoeg_g_slist_free_1 (node);
    goto <D.22580>;
    <D.22578>:
    head = &node->next;
    <D.22580>:
  }
  <D.18450>:
  D.22581 = *head;
  if (D.22581 != 0B) goto <D.18449>; else goto <D.18451>;
  <D.18451>:
  record_gclass_instantiation.26 = record_gclass_instantiation;
  if (record_gclass_instantiation.26 == 0) goto <D.22582>; else goto <D.22583>;
  <D.22582>:
  gclass_recorded_list.28 = gclass_recorded_list;
  if (gclass_recorded_list.28 != 0B) goto <D.22585>; else goto <D.22586>;
  <D.22585>:
  gclass_recorded_list.28 = gclass_recorded_list;
  monoeg_g_slist_free (gclass_recorded_list.28);
  gclass_recorded_list = 0B;
  <D.22586>:
  <D.22583>:
}


mono_class_find_enum_basetype (struct MonoClass * class)
{
  unsigned int D.22587;
  unsigned char D.22588;
  unsigned char D.22589;
  _Bool D.22590;
  long int D.22591;
  long int D.22592;
  struct MonoGenericContainer * D.22595;
  struct MonoGenericClass * D.22599;
  _Bool D.22602;
  long int D.22603;
  long int D.22604;
  unsigned int D.22607;
  unsigned int i.29;
  unsigned int D.22609;
  unsigned int D.22610;
  unsigned int D.22611;
  unsigned int D.22614;
  struct MonoImage * D.22615;
  int D.22616;
  struct MonoType * D.22619;
  const char * sig.30;
  const char * sig.31;
  char D.22622;
  const char * D.22625;
  short int D.22626;
  int D.22627;
  struct MonoGenericContext * D.22632;
  short unsigned int D.22633;
  struct MonoGenericContainer * container;
  struct MonoImage * m;
  const int top;
  int i;

  container = 0B;
  m = class->image;
  D.22587 = class->field.count;
  top = (const int) D.22587;
  D.22588 = BIT_FIELD_REF <*class, 8, 160>;
  D.22589 = D.22588 & 16;
  D.22590 = D.22589 == 0;
  D.22591 = (long int) D.22590;
  D.22592 = __builtin_expect (D.22591, 0);
  if (D.22592 != 0) goto <D.22593>; else goto <D.22594>;
  <D.22593>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "class.c", 1250, "class->enumtype");
  <D.22594>:
  D.22595 = class->generic_container;
  if (D.22595 != 0B) goto <D.22596>; else goto <D.22597>;
  <D.22596>:
  container = class->generic_container;
  goto <D.22598>;
  <D.22597>:
  D.22599 = class->generic_class;
  if (D.22599 != 0B) goto <D.22600>; else goto <D.22601>;
  <D.22600>:
  {
    struct MonoClass * gklass;

    D.22599 = class->generic_class;
    gklass = D.22599->container_class;
    container = gklass->generic_container;
    D.22602 = container == 0B;
    D.22603 = (long int) D.22602;
    D.22604 = __builtin_expect (D.22603, 0);
    if (D.22604 != 0) goto <D.22605>; else goto <D.22606>;
    <D.22605>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "class.c", 1258, "container");
    <D.22606>:
  }
  <D.22601>:
  <D.22598>:
  i = 0;
  goto <D.18763>;
  <D.18762>:
  {
    const char * sig;
    guint32 cols[3];
    int idx;
    struct MonoType * ftype;

    try
      {
        D.22607 = class->field.first;
        i.29 = (unsigned int) i;
        D.22609 = D.22607 + i.29;
        idx = (int) D.22609;
        mono_metadata_decode_table_row (m, 4, idx, &cols, 3);
        D.22610 = cols[0];
        D.22611 = D.22610 & 16;
        if (D.22611 != 0) goto <D.22612>; else goto <D.22613>;
        <D.22612>:
        // predicted unlikely by continue predictor.
        goto <D.18761>;
        <D.22613>:
        D.22614 = cols[2];
        D.22615 = class->image;
        D.22616 = mono_verifier_verify_field_signature (D.22615, D.22614, 0B);
        if (D.22616 == 0) goto <D.22617>; else goto <D.22618>;
        <D.22617>:
        D.22619 = 0B;
        return D.22619;
        <D.22618>:
        D.22614 = cols[2];
        sig.30 = mono_metadata_blob_heap (m, D.22614);
        sig = sig.30;
        sig.31 = sig;
        mono_metadata_decode_value (sig.31, &sig);
        sig.31 = sig;
        D.22622 = *sig.31;
        if (D.22622 != 6) goto <D.22623>; else goto <D.22624>;
        <D.22623>:
        D.22619 = 0B;
        return D.22619;
        <D.22624>:
        sig.31 = sig;
        D.22625 = sig.31 + 1;
        D.22610 = cols[0];
        D.22626 = (short int) D.22610;
        D.22627 = (int) D.22626;
        ftype = mono_metadata_parse_type_full (m, container, 5, D.22627, D.22625, &sig);
        if (ftype == 0B) goto <D.22628>; else goto <D.22629>;
        <D.22628>:
        D.22619 = 0B;
        return D.22619;
        <D.22629>:
        D.22599 = class->generic_class;
        if (D.22599 != 0B) goto <D.22630>; else goto <D.22631>;
        <D.22630>:
        D.22632 = mono_class_get_context (class);
        ftype = mono_class_inflate_generic_type (ftype, D.22632);
        D.22610 = cols[0];
        D.22633 = (short unsigned int) D.22610;
        ftype->attrs = D.22633;
        <D.22631>:
        D.22619 = ftype;
        return D.22619;
      }
    finally
      {
        sig = {CLOBBER};
        cols = {CLOBBER};
      }
  }
  <D.18761>:
  i = i + 1;
  <D.18763>:
  if (i < top) goto <D.18762>; else goto <D.18764>;
  <D.18764>:
  D.22619 = 0B;
  return D.22619;
}


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

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


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

  if (str != 0B) goto <D.22638>; else goto <D.22639>;
  <D.22638>:
  D.22640 = __strdup (str);
  return D.22640;
  <D.22639>:
  D.22640 = 0B;
  return D.22640;
}


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.22642>; else goto <D.22643>;
  <D.22642>:
  set_failure_from_loader_error (class, lerror);
  mono_error_set_from_loader_error (error);
  if (msg != 0B) goto <D.22644>; else goto <D.22645>;
  <D.22644>:
  monoeg_g_free (msg);
  <D.22645>:
  goto <D.22646>;
  <D.22643>:
  mono_class_set_failure (class, 7, msg);
  mono_error_set_type_load_class (error, class, msg);
  <D.22646>:
}


set_failure_from_loader_error (struct MonoClass * class, struct MonoLoaderError * error)
{
  unsigned char D.22647;
  int D.22648;
  char * D.22649;
  char * D.22650;
  struct MonoImage * D.22651;
  const char * D.22652;
  struct MonoClass * D.22653;
  const char * D.22656;
  int D.22660;
  unsigned int D.22664;
  void * exception_data;

  exception_data = 0B;
  D.22647 = error->exception_type;
  D.22648 = (int) D.22647;
  switch (D.22648) <default: <D.19899>, case 5: <D.19892>, case 6: <D.19893>, case 7: <D.19890>, case 8: <D.19896>, case 12: <D.19898>>
  <D.19890>:
  D.22649 = error->assembly_name;
  D.22650 = error->class_name;
  D.22651 = class->image;
  exception_data = concat_two_strings_with_zero (D.22651, D.22650, D.22649);
  goto <D.19891>;
  <D.19892>:
  D.22652 = error->member_name;
  D.22650 = error->class_name;
  D.22651 = class->image;
  exception_data = concat_two_strings_with_zero (D.22651, D.22650, D.22652);
  goto <D.19891>;
  <D.19893>:
  {
    const char * name_space;
    const char * class_name;

    D.22653 = error->klass;
    name_space = D.22653->name_space;
    if (name_space != 0B) goto <D.22654>; else goto <D.22655>;
    <D.22654>:
    D.22653 = error->klass;
    D.22656 = D.22653->name;
    class_name = monoeg_g_strdup_printf ("%s.%s", name_space, D.22656);
    goto <D.22657>;
    <D.22655>:
    D.22653 = error->klass;
    class_name = D.22653->name;
    <D.22657>:
    D.22652 = error->member_name;
    D.22651 = class->image;
    exception_data = concat_two_strings_with_zero (D.22651, class_name, D.22652);
    if (name_space != 0B) goto <D.22658>; else goto <D.22659>;
    <D.22658>:
    monoeg_g_free (class_name);
    <D.22659>:
    goto <D.19891>;
  }
  <D.19896>:
  {
    const char * msg;

    D.22660 = error->ref_only;
    if (D.22660 != 0) goto <D.22661>; else goto <D.22662>;
    <D.22661>:
    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.22663>;
    <D.22662>:
    msg = "Could not load file or assembly \'%s\' or one of its dependencies.";
    <D.22663>:
    D.22649 = error->assembly_name;
    D.22651 = class->image;
    exception_data = concat_two_strings_with_zero (D.22651, msg, D.22649);
    goto <D.19891>;
  }
  <D.19898>:
  exception_data = error->msg;
  goto <D.19891>;
  <D.19899>:
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "class.c", 4891);
  <D.19891>:
  D.22647 = error->exception_type;
  D.22664 = (unsigned int) D.22647;
  mono_class_set_failure (class, D.22664, exception_data);
}


concat_two_strings_with_zero (struct MonoImage * image, const char * s1, const char * s2)
{
  size_t iftmp.32;
  size_t iftmp.33;
  unsigned int D.22673;
  unsigned int D.22674;
  unsigned int len.34;
  const char * iftmp.35;
  const char * iftmp.36;
  long unsigned int len.37;
  int D.22685;
  _Bool D.22686;
  long int D.22687;
  long int D.22688;
  char * D.22691;
  int null_length;
  int len;
  char * s;
  int result;

  null_length = 6;
  if (s1 != 0B) goto <D.22666>; else goto <D.22667>;
  <D.22666>:
  iftmp.32 = strlen (s1);
  goto <D.22668>;
  <D.22667>:
  iftmp.32 = (size_t) null_length;
  <D.22668>:
  if (s2 != 0B) goto <D.22670>; else goto <D.22671>;
  <D.22670>:
  iftmp.33 = strlen (s2);
  goto <D.22672>;
  <D.22671>:
  iftmp.33 = (size_t) null_length;
  <D.22672>:
  D.22673 = iftmp.32 + iftmp.33;
  D.22674 = D.22673 + 2;
  len = (int) D.22674;
  len.34 = (unsigned int) len;
  s = mono_image_alloc (image, len.34);
  if (s2 != 0B) goto <D.22677>; else goto <D.22678>;
  <D.22677>:
  iftmp.35 = s2;
  goto <D.22679>;
  <D.22678>:
  iftmp.35 = "(null)";
  <D.22679>:
  if (s1 != 0B) goto <D.22681>; else goto <D.22682>;
  <D.22681>:
  iftmp.36 = s1;
  goto <D.22683>;
  <D.22682>:
  iftmp.36 = "(null)";
  <D.22683>:
  len.37 = (long unsigned int) len;
  result = monoeg_g_snprintf (s, len.37, "%s%c%s", iftmp.36, 0, iftmp.35);
  D.22685 = len + -1;
  D.22686 = D.22685 != result;
  D.22687 = (long int) D.22686;
  D.22688 = __builtin_expect (D.22687, 0);
  if (D.22688 != 0) goto <D.22689>; else goto <D.22690>;
  <D.22689>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "class.c", 4839, "result == len - 1");
  <D.22690>:
  D.22691 = s;
  return D.22691;
}


mono_dup_array_type (struct MonoImage * image, struct MonoArrayType * a)
{
  int * D.22695;
  unsigned char D.22698;
  unsigned int D.22699;
  unsigned int D.22700;
  void * D.22701;
  int * D.22702;
  unsigned char D.22705;
  unsigned int D.22706;
  unsigned int D.22707;
  void * D.22708;
  void * D.22712;
  void * D.22715;
  struct MonoArrayType * D.22716;

  if (image != 0B) goto <D.22693>; else goto <D.22694>;
  <D.22693>:
  a = mono_image_memdup (image, a, 16);
  D.22695 = a->sizes;
  if (D.22695 != 0B) goto <D.22696>; else goto <D.22697>;
  <D.22696>:
  D.22698 = a->numsizes;
  D.22699 = (unsigned int) D.22698;
  D.22700 = D.22699 * 4;
  D.22695 = a->sizes;
  D.22701 = mono_image_memdup (image, D.22695, D.22700);
  a->sizes = D.22701;
  <D.22697>:
  D.22702 = a->lobounds;
  if (D.22702 != 0B) goto <D.22703>; else goto <D.22704>;
  <D.22703>:
  D.22705 = a->numlobounds;
  D.22706 = (unsigned int) D.22705;
  D.22707 = D.22706 * 4;
  D.22702 = a->lobounds;
  D.22708 = mono_image_memdup (image, D.22702, D.22707);
  a->lobounds = D.22708;
  <D.22704>:
  goto <D.22709>;
  <D.22694>:
  a = monoeg_g_memdup (a, 16);
  D.22695 = a->sizes;
  if (D.22695 != 0B) goto <D.22710>; else goto <D.22711>;
  <D.22710>:
  D.22698 = a->numsizes;
  D.22699 = (unsigned int) D.22698;
  D.22700 = D.22699 * 4;
  D.22695 = a->sizes;
  D.22712 = monoeg_g_memdup (D.22695, D.22700);
  a->sizes = D.22712;
  <D.22711>:
  D.22702 = a->lobounds;
  if (D.22702 != 0B) goto <D.22713>; else goto <D.22714>;
  <D.22713>:
  D.22705 = a->numlobounds;
  D.22706 = (unsigned int) D.22705;
  D.22707 = D.22706 * 4;
  D.22702 = a->lobounds;
  D.22715 = monoeg_g_memdup (D.22702, D.22707);
  a->lobounds = D.22715;
  <D.22714>:
  <D.22709>:
  D.22716 = a;
  return D.22716;
}


mono_image_memdup (struct MonoImage * image, void * data, guint size)
{
  void * D.22718;
  void * res;

  res = mono_image_alloc (image, size);
  memcpy (res, data, size);
  D.22718 = res;
  return D.22718;
}


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

  D.22721 = __builtin_object_size (__dest, 0);
  D.22720 = __builtin___memcpy_chk (__dest, __src, __len, D.22721);
  return D.22720;
}


mono_metadata_signature_deep_dup (struct MonoImage * image, struct MonoMethodSignature * sig)
{
  struct MonoType * D.22723;
  struct MonoType * D.22724;
  struct MonoType * D.22725;
  struct MonoType * D.22726;
  short unsigned int D.22727;
  int D.22728;
  struct MonoMethodSignature * D.22729;
  int i;

  sig = mono_metadata_signature_dup_full (image, sig);
  D.22723 = sig->ret;
  D.22724 = mono_metadata_type_dup (image, D.22723);
  sig->ret = D.22724;
  i = 0;
  goto <D.18521>;
  <D.18520>:
  D.22725 = sig->params[i];
  D.22726 = mono_metadata_type_dup (image, D.22725);
  sig->params[i] = D.22726;
  i = i + 1;
  <D.18521>:
  D.22727 = sig->param_count;
  D.22728 = (int) D.22727;
  if (D.22728 > i) goto <D.18520>; else goto <D.18522>;
  <D.18522>:
  D.22729 = sig;
  return D.22729;
}


mono_type_get_name_full (struct MonoType * type, MonoTypeNameFormat format)
{
  char * D.22731;
  struct GString * result;

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


mono_type_get_name_recurse (struct MonoType * type, struct GString * str, gboolean is_recursed, MonoTypeNameFormat format)
{
  unsigned char D.22733;
  int D.22734;
  struct MonoArrayType * D.22735;
  unsigned char D.22736;
  MonoTypeNameFormat iftmp.38;
  struct MonoClass * D.22741;
  struct MonoType * D.22742;
  MonoTypeNameFormat iftmp.39;
  struct MonoClass * D.22751;
  struct MonoType * D.22752;
  MonoTypeNameFormat iftmp.40;
  struct MonoType * D.22759;
  struct MonoClass * D.22762;
  struct MonoGenericParam * D.22766;
  struct MonoGenericContainer * D.22767;
  struct MonoGenericParamInfo * D.22769;
  short unsigned int D.22770;
  int D.22771;
  const char * iftmp.41;
  struct MonoGenericParamInfo * iftmp.42;
  const char * D.22780;
  struct MonoClass * D.22781;
  struct MonoType * D.22784;
  const char * D.22789;
  char D.22790;
  const char * D.22795;
  int iftmp.43;
  int s.44;
  int D.22800;
  unsigned int D.22802;
  struct MonoGenericClass * D.22805;
  MonoTypeNameFormat iftmp.45;
  unsigned char D.22819;
  struct MonoType * D.22824;
  <unnamed-unsigned:22> D.22831;
  int D.22832;
  struct MonoGenericContainer * D.22837;
  unsigned int D.22840;
  struct MonoGenericParamFull * D.22848;
  unsigned int i.46;
  unsigned int D.22850;
  struct MonoGenericParamFull * D.22851;
  const char * D.22852;
  <unnamed-signed:31> D.22853;
  int D.22854;
  struct MonoClass * klass;

  D.22733 = type->type;
  D.22734 = (int) D.22733;
  switch (D.22734) <default: <D.18554>, case 15: <D.18550>, case 19: <D.18552>, case 20: <D.18540>, case 29: <D.18548>, case 30: <D.18553>>
  <D.18540>:
  {
    int i;
    int rank;
    MonoTypeNameFormat nested_format;

    D.22735 = type->data.array;
    D.22736 = D.22735->rank;
    rank = (int) D.22736;
    if (format != 3) goto <D.22738>; else goto <D.22739>;
    <D.22738>:
    iftmp.38 = format;
    goto <D.22740>;
    <D.22739>:
    iftmp.38 = 2;
    <D.22740>:
    nested_format = iftmp.38;
    D.22735 = type->data.array;
    D.22741 = D.22735->eklass;
    D.22742 = &D.22741->byval_arg;
    mono_type_get_name_recurse (D.22742, str, 0, nested_format);
    monoeg_g_string_append_c (str, 91);
    if (rank == 1) goto <D.22743>; else goto <D.22744>;
    <D.22743>:
    monoeg_g_string_append_c (str, 42);
    <D.22744>:
    i = 1;
    goto <D.18545>;
    <D.18544>:
    monoeg_g_string_append_c (str, 44);
    i = i + 1;
    <D.18545>:
    if (i < rank) goto <D.18544>; else goto <D.18546>;
    <D.18546>:
    monoeg_g_string_append_c (str, 93);
    mono_type_name_check_byref (type, str);
    if (format == 3) goto <D.22745>; else goto <D.22746>;
    <D.22745>:
    D.22735 = type->data.array;
    D.22741 = D.22735->eklass;
    _mono_type_get_assembly_name (D.22741, str);
    <D.22746>:
    goto <D.18547>;
  }
  <D.18548>:
  {
    MonoTypeNameFormat nested_format;

    if (format != 3) goto <D.22748>; else goto <D.22749>;
    <D.22748>:
    iftmp.39 = format;
    goto <D.22750>;
    <D.22749>:
    iftmp.39 = 2;
    <D.22750>:
    nested_format = iftmp.39;
    D.22751 = type->data.klass;
    D.22752 = &D.22751->byval_arg;
    mono_type_get_name_recurse (D.22752, str, 0, nested_format);
    monoeg_g_string_append (str, "[]");
    mono_type_name_check_byref (type, str);
    if (format == 3) goto <D.22753>; else goto <D.22754>;
    <D.22753>:
    D.22751 = type->data.klass;
    _mono_type_get_assembly_name (D.22751, str);
    <D.22754>:
    goto <D.18547>;
  }
  <D.18550>:
  {
    MonoTypeNameFormat nested_format;

    if (format != 3) goto <D.22756>; else goto <D.22757>;
    <D.22756>:
    iftmp.40 = format;
    goto <D.22758>;
    <D.22757>:
    iftmp.40 = 2;
    <D.22758>:
    nested_format = iftmp.40;
    D.22759 = type->data.type;
    mono_type_get_name_recurse (D.22759, str, 0, nested_format);
    monoeg_g_string_append_c (str, 42);
    mono_type_name_check_byref (type, str);
    if (format == 3) goto <D.22760>; else goto <D.22761>;
    <D.22760>:
    D.22759 = type->data.type;
    D.22762 = mono_class_from_mono_type (D.22759);
    _mono_type_get_assembly_name (D.22762, str);
    <D.22761>:
    goto <D.18547>;
  }
  <D.18552>:
  <D.18553>:
  D.22766 = type->data.generic_param;
  D.22767 = D.22766->owner;
  if (D.22767 == 0B) goto <D.22763>; else goto <D.22768>;
  <D.22768>:
  D.22766 = type->data.generic_param;
  D.22769 = &MEM[(struct MonoGenericParamFull *)D.22766].info;
  if (D.22769 == 0B) goto <D.22763>; else goto <D.22764>;
  <D.22763>:
  D.22766 = type->data.generic_param;
  D.22770 = D.22766->num;
  D.22771 = (int) D.22770;
  D.22733 = type->type;
  if (D.22733 == 19) goto <D.22773>; else goto <D.22774>;
  <D.22773>:
  iftmp.41 = "!";
  goto <D.22775>;
  <D.22774>:
  iftmp.41 = "!!";
  <D.22775>:
  monoeg_g_string_append_printf (str, "%s%d", iftmp.41, D.22771);
  goto <D.22765>;
  <D.22764>:
  D.22766 = type->data.generic_param;
  D.22767 = D.22766->owner;
  if (D.22767 != 0B) goto <D.22777>; else goto <D.22778>;
  <D.22777>:
  D.22766 = type->data.generic_param;
  iftmp.42 = &MEM[(struct MonoGenericParamFull *)D.22766].info;
  goto <D.22779>;
  <D.22778>:
  iftmp.42 = 0B;
  <D.22779>:
  D.22780 = iftmp.42->name;
  monoeg_g_string_append (str, D.22780);
  <D.22765>:
  mono_type_name_check_byref (type, str);
  goto <D.18547>;
  <D.18554>:
  klass = mono_class_from_mono_type (type);
  D.22781 = klass->nested_in;
  if (D.22781 != 0B) goto <D.22782>; else goto <D.22783>;
  <D.22782>:
  D.22781 = klass->nested_in;
  D.22784 = &D.22781->byval_arg;
  mono_type_get_name_recurse (D.22784, str, 1, format);
  if (format == 0) goto <D.22785>; else goto <D.22786>;
  <D.22785>:
  monoeg_g_string_append_c (str, 46);
  goto <D.22787>;
  <D.22786>:
  monoeg_g_string_append_c (str, 43);
  <D.22787>:
  goto <D.22788>;
  <D.22783>:
  D.22789 = klass->name_space;
  D.22790 = *D.22789;
  if (D.22790 != 0) goto <D.22791>; else goto <D.22792>;
  <D.22791>:
  D.22789 = klass->name_space;
  monoeg_g_string_append (str, D.22789);
  monoeg_g_string_append_c (str, 46);
  <D.22792>:
  <D.22788>:
  if (format == 0) goto <D.22793>; else goto <D.22794>;
  <D.22793>:
  {
    char * s;
    int len;

    D.22795 = klass->name;
    s = __builtin_strchr (D.22795, 96);
    if (s != 0B) goto <D.22797>; else goto <D.22798>;
    <D.22797>:
    s.44 = (int) s;
    D.22795 = klass->name;
    D.22800 = (int) D.22795;
    iftmp.43 = s.44 - D.22800;
    goto <D.22801>;
    <D.22798>:
    D.22795 = klass->name;
    D.22802 = strlen (D.22795);
    iftmp.43 = (int) D.22802;
    <D.22801>:
    len = iftmp.43;
    D.22795 = klass->name;
    monoeg_g_string_append_len (str, D.22795, len);
  }
  goto <D.22803>;
  <D.22794>:
  D.22795 = klass->name;
  monoeg_g_string_append (str, D.22795);
  <D.22803>:
  if (is_recursed != 0) goto <D.18547>; else goto <D.22804>;
  <D.22804>:
  D.22805 = klass->generic_class;
  if (D.22805 != 0B) goto <D.22806>; else goto <D.22807>;
  <D.22806>:
  {
    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.22809>; else goto <D.22810>;
    <D.22809>:
    iftmp.45 = format;
    goto <D.22811>;
    <D.22810>:
    iftmp.45 = 3;
    <D.22811>:
    nested_format = iftmp.45;
    if (format == 0) goto <D.22812>; else goto <D.22813>;
    <D.22812>:
    monoeg_g_string_append_c (str, 60);
    goto <D.22814>;
    <D.22813>:
    monoeg_g_string_append_c (str, 91);
    <D.22814>:
    i = 0;
    goto <D.18563>;
    <D.18562>:
    {
      struct MonoType * t;

      t = inst->type_argv[i];
      if (i != 0) goto <D.22815>; else goto <D.22816>;
      <D.22815>:
      monoeg_g_string_append_c (str, 44);
      <D.22816>:
      if (nested_format == 3) goto <D.22817>; else goto <D.22818>;
      <D.22817>:
      D.22819 = t->type;
      if (D.22819 != 19) goto <D.22820>; else goto <D.22821>;
      <D.22820>:
      D.22733 = type->type;
      if (D.22733 != 30) goto <D.22822>; else goto <D.22823>;
      <D.22822>:
      monoeg_g_string_append_c (str, 91);
      <D.22823>:
      <D.22821>:
      <D.22818>:
      D.22824 = inst->type_argv[i];
      mono_type_get_name_recurse (D.22824, str, 0, nested_format);
      if (nested_format == 3) goto <D.22825>; else goto <D.22826>;
      <D.22825>:
      D.22819 = t->type;
      if (D.22819 != 19) goto <D.22827>; else goto <D.22828>;
      <D.22827>:
      D.22733 = type->type;
      if (D.22733 != 30) goto <D.22829>; else goto <D.22830>;
      <D.22829>:
      monoeg_g_string_append_c (str, 93);
      <D.22830>:
      <D.22828>:
      <D.22826>:
    }
    i = i + 1;
    <D.18563>:
    D.22831 = inst->type_argc;
    D.22832 = (int) D.22831;
    if (D.22832 > i) goto <D.18562>; else goto <D.18564>;
    <D.18564>:
    if (format == 0) goto <D.22833>; else goto <D.22834>;
    <D.22833>:
    monoeg_g_string_append_c (str, 62);
    goto <D.22835>;
    <D.22834>:
    monoeg_g_string_append_c (str, 93);
    <D.22835>:
  }
  goto <D.22836>;
  <D.22807>:
  D.22837 = klass->generic_container;
  if (D.22837 != 0B) goto <D.22838>; else goto <D.22839>;
  <D.22838>:
  D.22840 = format + 4294967294;
  if (D.22840 > 1) goto <D.22841>; else goto <D.22842>;
  <D.22841>:
  {
    int i;

    if (format == 0) goto <D.22843>; else goto <D.22844>;
    <D.22843>:
    monoeg_g_string_append_c (str, 60);
    goto <D.22845>;
    <D.22844>:
    monoeg_g_string_append_c (str, 91);
    <D.22845>:
    i = 0;
    goto <D.18567>;
    <D.18566>:
    if (i != 0) goto <D.22846>; else goto <D.22847>;
    <D.22846>:
    monoeg_g_string_append_c (str, 44);
    <D.22847>:
    D.22837 = klass->generic_container;
    D.22848 = D.22837->type_params;
    i.46 = (unsigned int) i;
    D.22850 = i.46 * 32;
    D.22851 = D.22848 + D.22850;
    D.22852 = D.22851->info.name;
    monoeg_g_string_append (str, D.22852);
    i = i + 1;
    <D.18567>:
    D.22837 = klass->generic_container;
    D.22853 = D.22837->type_argc;
    D.22854 = (int) D.22853;
    if (D.22854 > i) goto <D.18566>; else goto <D.18568>;
    <D.18568>:
    if (format == 0) goto <D.22855>; else goto <D.22856>;
    <D.22855>:
    monoeg_g_string_append_c (str, 62);
    goto <D.22857>;
    <D.22856>:
    monoeg_g_string_append_c (str, 93);
    <D.22857>:
  }
  <D.22842>:
  <D.22839>:
  <D.22836>:
  mono_type_name_check_byref (type, str);
  if (format == 3) goto <D.22858>; else goto <D.22859>;
  <D.22858>:
  D.22733 = type->type;
  if (D.22733 != 19) goto <D.22860>; else goto <D.22861>;
  <D.22860>:
  D.22733 = type->type;
  if (D.22733 != 30) goto <D.22862>; else goto <D.22863>;
  <D.22862>:
  _mono_type_get_assembly_name (klass, str);
  <D.22863>:
  <D.22861>:
  <D.22859>:
  goto <D.18547>;
  <D.18547>:
}


mono_type_name_check_byref (struct MonoType * type, struct GString * str)
{
  unsigned char D.22864;
  unsigned char D.22865;

  D.22864 = BIT_FIELD_REF <*type, 8, 56>;
  D.22865 = D.22864 & 64;
  if (D.22865 != 0) goto <D.22866>; else goto <D.22867>;
  <D.22866>:
  monoeg_g_string_append_c (str, 38);
  <D.22867>:
}


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

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


mono_type_get_full_name (struct MonoClass * class)
{
  char * D.22870;
  struct MonoType * D.22871;

  D.22871 = mono_class_get_type (class);
  D.22870 = mono_type_get_name_full (D.22871, 1);
  return D.22870;
}


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

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


mono_type_get_underlying_type (struct MonoType * type)
{
  unsigned char D.22875;
  struct MonoClass * D.22878;
  unsigned char D.22879;
  unsigned char D.22880;
  unsigned char D.22883;
  unsigned char D.22884;
  struct MonoType * D.22887;
  struct MonoGenericClass * D.22890;
  struct MonoClass * D.22891;
  unsigned char D.22892;
  unsigned char D.22893;

  D.22875 = type->type;
  if (D.22875 == 17) goto <D.22876>; else goto <D.22877>;
  <D.22876>:
  D.22878 = type->data.klass;
  D.22879 = BIT_FIELD_REF <*D.22878, 8, 160>;
  D.22880 = D.22879 & 16;
  if (D.22880 != 0) goto <D.22881>; else goto <D.22882>;
  <D.22881>:
  D.22883 = BIT_FIELD_REF <*type, 8, 56>;
  D.22884 = D.22883 & 64;
  if (D.22884 == 0) goto <D.22885>; else goto <D.22886>;
  <D.22885>:
  D.22878 = type->data.klass;
  D.22887 = mono_class_enum_basetype (D.22878);
  return D.22887;
  <D.22886>:
  <D.22882>:
  <D.22877>:
  D.22875 = type->type;
  if (D.22875 == 21) goto <D.22888>; else goto <D.22889>;
  <D.22888>:
  D.22890 = type->data.generic_class;
  D.22891 = D.22890->container_class;
  D.22892 = BIT_FIELD_REF <*D.22891, 8, 160>;
  D.22893 = D.22892 & 16;
  if (D.22893 != 0) goto <D.22894>; else goto <D.22895>;
  <D.22894>:
  D.22883 = BIT_FIELD_REF <*type, 8, 56>;
  D.22884 = D.22883 & 64;
  if (D.22884 == 0) goto <D.22896>; else goto <D.22897>;
  <D.22896>:
  D.22890 = type->data.generic_class;
  D.22891 = D.22890->container_class;
  D.22887 = mono_class_enum_basetype (D.22891);
  return D.22887;
  <D.22897>:
  <D.22895>:
  <D.22889>:
  D.22887 = type;
  return D.22887;
}


mono_class_is_open_constructed_type (struct MonoType * t)
{
  unsigned char D.22899;
  int D.22900;
  gboolean D.22901;
  struct MonoClass * D.22902;
  struct MonoType * D.22903;
  struct MonoArrayType * D.22904;
  struct MonoClass * D.22905;
  struct MonoType * D.22906;
  struct MonoType * D.22907;
  struct MonoGenericClass * D.22908;
  struct MonoGenericInst * D.22909;
  <unnamed-unsigned:1> D.22910;
  struct MonoGenericContainer * D.22911;
  _Bool D.22912;

  D.22899 = t->type;
  D.22900 = (int) D.22899;
  switch (D.22900) <default: <D.18594>, case 15: <D.18590>, case 17: <D.18593>, case 18: <D.18592>, case 19: <D.18586>, case 20: <D.18589>, case 21: <D.18591>, case 29: <D.18588>, case 30: <D.18587>>
  <D.18586>:
  <D.18587>:
  D.22901 = 1;
  return D.22901;
  <D.18588>:
  D.22902 = t->data.klass;
  D.22903 = &D.22902->byval_arg;
  D.22901 = mono_class_is_open_constructed_type (D.22903);
  return D.22901;
  <D.18589>:
  D.22904 = t->data.array;
  D.22905 = D.22904->eklass;
  D.22906 = &D.22905->byval_arg;
  D.22901 = mono_class_is_open_constructed_type (D.22906);
  return D.22901;
  <D.18590>:
  D.22907 = t->data.type;
  D.22901 = mono_class_is_open_constructed_type (D.22907);
  return D.22901;
  <D.18591>:
  D.22908 = t->data.generic_class;
  D.22909 = D.22908->context.class_inst;
  D.22910 = D.22909->is_open;
  D.22901 = (gboolean) D.22910;
  return D.22901;
  <D.18592>:
  <D.18593>:
  D.22902 = t->data.klass;
  D.22911 = D.22902->generic_container;
  D.22912 = D.22911 != 0B;
  D.22901 = (gboolean) D.22912;
  return D.22901;
  <D.18594>:
  D.22901 = 0;
  return D.22901;
}


mono_generic_class_get_context (struct MonoGenericClass * gclass)
{
  struct MonoGenericContext * D.22914;

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


mono_class_get_context (struct MonoClass * class)
{
  struct MonoGenericContext * D.22916;
  struct MonoGenericContext * iftmp.47;
  struct MonoGenericClass * D.22918;

  D.22918 = class->generic_class;
  if (D.22918 != 0B) goto <D.22919>; else goto <D.22920>;
  <D.22919>:
  D.22918 = class->generic_class;
  iftmp.47 = mono_generic_class_get_context (D.22918);
  goto <D.22921>;
  <D.22920>:
  iftmp.47 = 0B;
  <D.22921>:
  D.22916 = iftmp.47;
  return D.22916;
}


mono_class_get_generic_container (struct MonoClass * klass)
{
  unsigned char D.22923;
  unsigned char D.22924;
  _Bool D.22925;
  long int D.22926;
  long int D.22927;
  struct MonoGenericContainer * D.22930;

  D.22923 = BIT_FIELD_REF <*klass, 8, 192>;
  D.22924 = D.22923 & 4;
  D.22925 = D.22924 == 0;
  D.22926 = (long int) D.22925;
  D.22927 = __builtin_expect (D.22926, 0);
  if (D.22927 != 0) goto <D.22928>; else goto <D.22929>;
  <D.22928>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "class.c", 752, "klass->is_generic");
  <D.22929>:
  D.22930 = klass->generic_container;
  return D.22930;
}


mono_class_get_generic_class (struct MonoClass * klass)
{
  unsigned char D.22932;
  unsigned char D.22933;
  _Bool D.22934;
  long int D.22935;
  long int D.22936;
  struct MonoGenericClass * D.22939;

  D.22932 = BIT_FIELD_REF <*klass, 8, 192>;
  D.22933 = D.22932 & 8;
  D.22934 = D.22933 == 0;
  D.22935 = (long int) D.22934;
  D.22936 = __builtin_expect (D.22935, 0);
  if (D.22936 != 0) goto <D.22937>; else goto <D.22938>;
  <D.22937>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "class.c", 765, "klass->is_inflated");
  <D.22938>:
  D.22939 = klass->generic_class;
  return D.22939;
}


mono_class_inflate_generic_type_with_mempool (struct MonoImage * image, struct MonoType * type, struct MonoGenericContext * context, struct MonoError * error)
{
  int D.22943;
  struct MonoType * D.22946;
  long unsigned int D.22951;
  long unsigned int D.22952;
  struct MonoType * inflated;

  inflated = 0B;
  mono_error_init (error);
  if (context != 0B) goto <D.22941>; else goto <D.22942>;
  <D.22941>:
  inflated = inflate_generic_type (image, type, context, error);
  <D.22942>:
  D.22943 = mono_error_ok (error);
  if (D.22943 == 0) goto <D.22944>; else goto <D.22945>;
  <D.22944>:
  D.22946 = 0B;
  return D.22946;
  <D.22945>:
  if (inflated == 0B) goto <D.22947>; else goto <D.22948>;
  <D.22947>:
  {
    struct MonoType * shared;

    shared = mono_metadata_get_shared_type (type);
    if (shared != 0B) goto <D.22949>; else goto <D.22950>;
    <D.22949>:
    D.22946 = shared;
    return D.22946;
    <D.22950>:
    D.22946 = mono_metadata_type_dup (image, type);
    return D.22946;
  }
  <D.22948>:
  D.22951 = mono_stats.inflated_type_count;
  D.22952 = D.22951 + 1;
  mono_stats.inflated_type_count = D.22952;
  D.22946 = inflated;
  return D.22946;
}


inflate_generic_type (struct MonoImage * image, struct MonoType * type, struct MonoGenericContext * context, struct MonoError * error)
{
  unsigned char D.22954;
  int D.22955;
  struct MonoGenericParam * D.22956;
  short unsigned int D.22957;
  struct MonoType *[0:] * D.22961;
  struct MonoType * D.22962;
  <unnamed-unsigned:22> D.22963;
  int D.22964;
  struct MonoGenericParamInfo * iftmp.48;
  struct MonoGenericContainer * D.22968;
  const char * iftmp.49;
  struct MonoType * D.22976;
  int D.22977;
  struct MonoGenericParamInfo * iftmp.50;
  unsigned char D.22984;
  int D.22985;
  const char * iftmp.51;
  <unnamed-unsigned:1> D.22990;
  short unsigned int D.22991;
  <unnamed-unsigned:22> D.22994;
  int D.22995;
  struct MonoGenericParamInfo * iftmp.52;
  const char * iftmp.53;
  struct MonoType * D.23006;
  int D.23007;
  struct MonoGenericParamInfo * iftmp.54;
  unsigned char D.23014;
  int D.23015;
  const char * iftmp.55;
  struct MonoType * D.23020;
  int D.23024;
  struct MonoClass * D.23025;
  struct MonoArrayType * D.23026;
  struct MonoType * D.23027;
  int D.23031;
  struct MonoArrayType * D.23032;
  struct MonoClass * D.23033;
  struct MonoGenericInst * D.23034;
  unsigned char D.23035;
  unsigned char D.23036;
  int D.23039;
  <unnamed-unsigned:1> D.23044;
  int D.23045;
  struct MonoClass * D.23046;
  struct MonoGenericClass * D.23047;
  struct MonoGenericInst * D.23052;
  int D.23053;
  struct MonoImage * D.23058;
  <unnamed-unsigned:1> D.23059;
  int D.23060;

  mono_error_init (error);
  D.22954 = type->type;
  D.22955 = (int) D.22954;
  switch (D.22955) <default: <D.18636>, case 17: <D.18630>, case 18: <D.18629>, case 19: <D.18611>, case 20: <D.18621>, case 21: <D.18625>, case 29: <D.18617>, case 30: <D.18605>>
  <D.18605>:
  {
    struct MonoType * nt;
    int num;
    struct MonoGenericInst * inst;

    D.22956 = type->data.generic_param;
    D.22957 = D.22956->num;
    num = (int) D.22957;
    inst = context->method_inst;
    if (inst == 0B) goto <D.22958>; else goto <D.22960>;
    <D.22960>:
    D.22961 = &inst->type_argv;
    if (D.22961 == 0B) goto <D.22958>; else goto <D.22959>;
    <D.22958>:
    D.22962 = 0B;
    return D.22962;
    <D.22959>:
    D.22963 = inst->type_argc;
    D.22964 = (int) D.22963;
    if (D.22964 <= num) goto <D.22965>; else goto <D.22966>;
    <D.22965>:
    {
      struct MonoGenericParamInfo * info;

      D.22956 = type->data.generic_param;
      D.22968 = D.22956->owner;
      if (D.22968 != 0B) goto <D.22969>; else goto <D.22970>;
      <D.22969>:
      D.22956 = type->data.generic_param;
      iftmp.48 = &MEM[(struct MonoGenericParamFull *)D.22956].info;
      goto <D.22971>;
      <D.22970>:
      iftmp.48 = 0B;
      <D.22971>:
      info = iftmp.48;
      D.22963 = inst->type_argc;
      D.22964 = (int) D.22963;
      if (info != 0B) goto <D.22973>; else goto <D.22974>;
      <D.22973>:
      iftmp.49 = info->name;
      goto <D.22975>;
      <D.22974>:
      iftmp.49 = "";
      <D.22975>:
      mono_error_set_bad_image (error, image, "MVAR %d (%s) cannot be expanded in this context with %d instantiations", num, iftmp.49, D.22964);
      D.22962 = 0B;
      return D.22962;
    }
    <D.22966>:
    D.22976 = inst->type_argv[num];
    D.22977 = is_valid_generic_argument (D.22976);
    if (D.22977 == 0) goto <D.22978>; else goto <D.22979>;
    <D.22978>:
    {
      struct MonoGenericParamInfo * info;

      D.22956 = type->data.generic_param;
      D.22968 = D.22956->owner;
      if (D.22968 != 0B) goto <D.22981>; else goto <D.22982>;
      <D.22981>:
      D.22956 = type->data.generic_param;
      iftmp.50 = &MEM[(struct MonoGenericParamFull *)D.22956].info;
      goto <D.22983>;
      <D.22982>:
      iftmp.50 = 0B;
      <D.22983>:
      info = iftmp.50;
      D.22976 = inst->type_argv[num];
      D.22984 = D.22976->type;
      D.22985 = (int) D.22984;
      if (info != 0B) goto <D.22987>; else goto <D.22988>;
      <D.22987>:
      iftmp.51 = info->name;
      goto <D.22989>;
      <D.22988>:
      iftmp.51 = "";
      <D.22989>:
      mono_error_set_bad_image (error, image, "MVAR %d (%s) cannot be expanded with type 0x%x", num, iftmp.51, D.22985);
      D.22962 = 0B;
      return D.22962;
    }
    <D.22979>:
    D.22976 = inst->type_argv[num];
    nt = mono_metadata_type_dup (image, D.22976);
    D.22990 = type->byref;
    nt->byref = D.22990;
    D.22991 = type->attrs;
    nt->attrs = D.22991;
    D.22962 = nt;
    return D.22962;
  }
  <D.18611>:
  {
    struct MonoType * nt;
    int num;
    struct MonoGenericInst * inst;

    D.22956 = type->data.generic_param;
    D.22957 = D.22956->num;
    num = (int) D.22957;
    inst = context->class_inst;
    if (inst == 0B) goto <D.22992>; else goto <D.22993>;
    <D.22992>:
    D.22962 = 0B;
    return D.22962;
    <D.22993>:
    D.22994 = inst->type_argc;
    D.22995 = (int) D.22994;
    if (D.22995 <= num) goto <D.22996>; else goto <D.22997>;
    <D.22996>:
    {
      struct MonoGenericParamInfo * info;

      D.22956 = type->data.generic_param;
      D.22968 = D.22956->owner;
      if (D.22968 != 0B) goto <D.22999>; else goto <D.23000>;
      <D.22999>:
      D.22956 = type->data.generic_param;
      iftmp.52 = &MEM[(struct MonoGenericParamFull *)D.22956].info;
      goto <D.23001>;
      <D.23000>:
      iftmp.52 = 0B;
      <D.23001>:
      info = iftmp.52;
      D.22994 = inst->type_argc;
      D.22995 = (int) D.22994;
      if (info != 0B) goto <D.23003>; else goto <D.23004>;
      <D.23003>:
      iftmp.53 = info->name;
      goto <D.23005>;
      <D.23004>:
      iftmp.53 = "";
      <D.23005>:
      mono_error_set_bad_image (error, image, "VAR %d (%s) cannot be expanded in this context with %d instantiations", num, iftmp.53, D.22995);
      D.22962 = 0B;
      return D.22962;
    }
    <D.22997>:
    D.23006 = inst->type_argv[num];
    D.23007 = is_valid_generic_argument (D.23006);
    if (D.23007 == 0) goto <D.23008>; else goto <D.23009>;
    <D.23008>:
    {
      struct MonoGenericParamInfo * info;

      D.22956 = type->data.generic_param;
      D.22968 = D.22956->owner;
      if (D.22968 != 0B) goto <D.23011>; else goto <D.23012>;
      <D.23011>:
      D.22956 = type->data.generic_param;
      iftmp.54 = &MEM[(struct MonoGenericParamFull *)D.22956].info;
      goto <D.23013>;
      <D.23012>:
      iftmp.54 = 0B;
      <D.23013>:
      info = iftmp.54;
      D.23006 = inst->type_argv[num];
      D.23014 = D.23006->type;
      D.23015 = (int) D.23014;
      if (info != 0B) goto <D.23017>; else goto <D.23018>;
      <D.23017>:
      iftmp.55 = info->name;
      goto <D.23019>;
      <D.23018>:
      iftmp.55 = "";
      <D.23019>:
      mono_error_set_bad_image (error, image, "VAR %d (%s) cannot be expanded with type 0x%x", num, iftmp.55, D.23015);
      D.22962 = 0B;
      return D.22962;
    }
    <D.23009>:
    D.23006 = inst->type_argv[num];
    nt = mono_metadata_type_dup (image, D.23006);
    D.22990 = type->byref;
    nt->byref = D.22990;
    D.22991 = type->attrs;
    nt->attrs = D.22991;
    D.22962 = nt;
    return D.22962;
  }
  <D.18617>:
  {
    struct MonoClass * eclass;
    struct MonoType * nt;
    struct MonoType * inflated;

    eclass = type->data.klass;
    D.23020 = &eclass->byval_arg;
    inflated = inflate_generic_type (0B, D.23020, context, error);
    if (inflated == 0B) goto <D.23021>; else goto <D.23023>;
    <D.23023>:
    D.23024 = mono_error_ok (error);
    if (D.23024 == 0) goto <D.23021>; else goto <D.23022>;
    <D.23021>:
    D.22962 = 0B;
    return D.22962;
    <D.23022>:
    nt = mono_metadata_type_dup (image, type);
    D.23025 = mono_class_from_mono_type (inflated);
    nt->data.klass = D.23025;
    mono_metadata_free_type (inflated);
    D.22962 = nt;
    return D.22962;
  }
  <D.18621>:
  {
    struct MonoClass * eclass;
    struct MonoType * nt;
    struct MonoType * inflated;

    D.23026 = type->data.array;
    eclass = D.23026->eklass;
    D.23027 = &eclass->byval_arg;
    inflated = inflate_generic_type (0B, D.23027, context, error);
    if (inflated == 0B) goto <D.23028>; else goto <D.23030>;
    <D.23030>:
    D.23031 = mono_error_ok (error);
    if (D.23031 == 0) goto <D.23028>; else goto <D.23029>;
    <D.23028>:
    D.22962 = 0B;
    return D.22962;
    <D.23029>:
    nt = mono_metadata_type_dup (image, type);
    D.23032 = nt->data.array;
    D.23033 = mono_class_from_mono_type (inflated);
    D.23032->eklass = D.23033;
    mono_metadata_free_type (inflated);
    D.22962 = nt;
    return D.22962;
  }
  <D.18625>:
  {
    struct MonoGenericClass * gclass;
    struct MonoGenericInst * inst;
    struct MonoType * nt;

    gclass = type->data.generic_class;
    D.23034 = gclass->context.class_inst;
    D.23035 = BIT_FIELD_REF <*D.23034, 8, 48>;
    D.23036 = D.23035 & 64;
    if (D.23036 == 0) goto <D.23037>; else goto <D.23038>;
    <D.23037>:
    D.22962 = 0B;
    return D.22962;
    <D.23038>:
    D.23034 = gclass->context.class_inst;
    inst = mono_metadata_inflate_generic_inst (D.23034, context, error);
    D.23039 = mono_error_ok (error);
    if (D.23039 == 0) goto <D.23040>; else goto <D.23041>;
    <D.23040>:
    D.22962 = 0B;
    return D.22962;
    <D.23041>:
    D.23034 = gclass->context.class_inst;
    if (D.23034 != inst) goto <D.23042>; else goto <D.23043>;
    <D.23042>:
    D.23044 = gclass->is_dynamic;
    D.23045 = (int) D.23044;
    D.23046 = gclass->container_class;
    gclass = mono_metadata_lookup_generic_class (D.23046, inst, D.23045);
    <D.23043>:
    D.23047 = type->data.generic_class;
    if (D.23047 == gclass) goto <D.23048>; else goto <D.23049>;
    <D.23048>:
    D.22962 = 0B;
    return D.22962;
    <D.23049>:
    nt = mono_metadata_type_dup (image, type);
    nt->data.generic_class = gclass;
    D.22962 = nt;
    return D.22962;
  }
  <D.18629>:
  <D.18630>:
  {
    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.23050>; else goto <D.23051>;
    <D.23050>:
    D.22962 = 0B;
    return D.22962;
    <D.23051>:
    D.23052 = container->context.class_inst;
    inst = mono_metadata_inflate_generic_inst (D.23052, context, error);
    D.23053 = mono_error_ok (error);
    if (D.23053 == 0) goto <D.23054>; else goto <D.23055>;
    <D.23054>:
    D.22962 = 0B;
    return D.22962;
    <D.23055>:
    D.23052 = container->context.class_inst;
    if (D.23052 == inst) goto <D.23056>; else goto <D.23057>;
    <D.23056>:
    D.22962 = 0B;
    return D.22962;
    <D.23057>:
    D.23058 = klass->image;
    D.23059 = D.23058->dynamic;
    D.23060 = (int) D.23059;
    gclass = mono_metadata_lookup_generic_class (klass, inst, D.23060);
    nt = mono_metadata_type_dup (image, type);
    nt->type = 21;
    nt->data.generic_class = gclass;
    D.22962 = nt;
    return D.22962;
  }
  <D.18636>:
  D.22962 = 0B;
  return D.22962;
  D.22962 = 0B;
  return D.22962;
}


is_valid_generic_argument (struct MonoType * type)
{
  unsigned char D.23062;
  int D.23063;
  gboolean D.23064;

  D.23062 = type->type;
  D.23063 = (int) D.23062;
  switch (D.23063) <default: <D.23065>, case 1: <D.18598>>
  <D.18598>:
  D.23064 = 0;
  return D.23064;
  <D.23065>:
  D.23064 = 1;
  return D.23064;
}


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

  try
    {
      result = mono_class_inflate_generic_type_checked (type, context, &error);
      D.23067 = mono_error_ok (&error);
      if (D.23067 == 0) goto <D.23068>; else goto <D.23069>;
      <D.23068>:
      mono_error_cleanup (&error);
      D.23070 = 0B;
      return D.23070;
      <D.23069>:
      D.23070 = result;
      return D.23070;
    }
  finally
    {
      error = {CLOBBER};
    }
}


mono_class_inflate_generic_type_checked (struct MonoType * type, struct MonoGenericContext * context, struct MonoError * error)
{
  struct MonoType * D.23073;

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


mono_class_inflate_generic_class (struct MonoClass * gklass, struct MonoGenericContext * context)
{
  int D.23075;
  _Bool D.23076;
  long int D.23077;
  long int D.23078;
  struct MonoClass * D.23081;
  struct MonoError error;
  struct MonoClass * res;

  try
    {
      res = mono_class_inflate_generic_class_checked (gklass, context, &error);
      D.23075 = mono_error_ok (&error);
      D.23076 = D.23075 == 0;
      D.23077 = (long int) D.23076;
      D.23078 = __builtin_expect (D.23077, 0);
      if (D.23078 != 0) goto <D.23079>; else goto <D.23080>;
      <D.23079>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "class.c", 905, "mono_error_ok (&error)");
      <D.23080>:
      D.23081 = res;
      return D.23081;
    }
  finally
    {
      error = {CLOBBER};
    }
}


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

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


mono_class_inflate_generic_method_full (struct MonoMethod * method, struct MonoClass * klass_hint, struct MonoGenericContext * context)
{
  int D.23086;
  const char * D.23089;
  struct MonoMethod * D.23090;
  struct MonoError error;
  struct MonoMethod * res;

  try
    {
      res = mono_class_inflate_generic_method_full_checked (method, klass_hint, context, &error);
      D.23086 = mono_error_ok (&error);
      if (D.23086 == 0) goto <D.23087>; else goto <D.23088>;
      <D.23087>:
      D.23089 = mono_error_get_message (&error);
      monoeg_g_log (0B, 4, "Could not inflate generic method due to %s", D.23089);
      <D.18708>:
      goto <D.18708>;
      <D.23088>:
      D.23090 = res;
      return D.23090;
    }
  finally
    {
      error = {CLOBBER};
    }
}


mono_class_inflate_generic_method_full_checked (struct MonoMethod * method, struct MonoClass * klass_hint, struct MonoGenericContext * context, struct MonoError * error)
{
  int D.23093;
  struct MonoMethod * D.23096;
  int D.23097;
  unsigned char D.23100;
  unsigned char D.23101;
  unsigned char D.23105;
  struct MonoGenericInst * D.23107;
  struct MonoClass * D.23108;
  struct MonoGenericContainer * D.23109;
  struct MonoGenericInst * D.23111;
  int iftmp.56;
  struct MonoImage * D.23116;
  unsigned char D.23117;
  unsigned char D.23118;
  unsigned char D.23120;
  unsigned char D.23121;
  struct MonoGenericContainer * D.23123;
  struct MonoGenericInst * D.23124;
  unsigned char D.23126;
  <unnamed-unsigned:1> D.23127;
  struct MonoGenericContainer * D.23132;
  struct MonoGenericInst * D.23133;
  struct MonoMethod * D.23136;
  struct MonoClass * D.23137;
  struct MonoGenericClass * D.23138;
  _Bool D.23139;
  long int D.23140;
  long int D.23141;
  struct MonoGenericContainer * D.23144;
  struct MonoGenericInst * D.23147;
  struct MonoGenericInst * D.23151;
  long unsigned int D.23154;
  long unsigned int D.23155;
  unsigned int inflated_methods_size.57;
  unsigned int inflated_methods_size.58;
  const char * D.23160;
  unsigned char D.23161;
  unsigned char D.23162;
  struct MonoMethodPInvoke * D.23165;
  struct MonoMethod * D.23167;
  struct MonoGenericClass * D.23175;
  struct MonoClass * D.23177;
  struct MonoGenericInst * D.23179;
  struct MonoClass * D.23182;
  struct MonoType * D.23185;
  int D.23186;
  struct MonoClass * iftmp.59;
  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.18724>;
      <D.18723>:
      {
        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.23093 = mono_error_ok (error);
        if (D.23093 == 0) goto <D.23094>; else goto <D.23095>;
        <D.23094>:
        D.23096 = 0B;
        return D.23096;
        <D.23095>:
        context = &tmp_context;
        D.23097 = mono_metadata_generic_context_equal (method_context, context);
        if (D.23097 != 0) goto <D.23098>; else goto <D.23099>;
        <D.23098>:
        D.23096 = method;
        return D.23096;
        <D.23099>:
        method = imethod->declaring;
      }
      <D.18724>:
      D.23100 = BIT_FIELD_REF <*method, 8, 168>;
      D.23101 = D.23100 & 16;
      if (D.23101 != 0) goto <D.18723>; else goto <D.18725>;
      <D.18725>:
      D.23100 = BIT_FIELD_REF <*method, 8, 168>;
      D.23105 = D.23100 & 8;
      if (D.23105 == 0) goto <D.23104>; else goto <D.23106>;
      <D.23106>:
      D.23107 = context->method_inst;
      if (D.23107 == 0B) goto <D.23104>; else goto <D.23103>;
      <D.23104>:
      D.23108 = method->klass;
      D.23109 = D.23108->generic_container;
      if (D.23109 == 0B) goto <D.23102>; else goto <D.23110>;
      <D.23110>:
      D.23111 = context->class_inst;
      if (D.23111 == 0B) goto <D.23102>; else goto <D.23103>;
      <D.23102>:
      D.23096 = method;
      return D.23096;
      <D.23103>:
      D.23100 = BIT_FIELD_REF <*method, 8, 168>;
      D.23105 = D.23100 & 8;
      if (D.23105 != 0) goto <D.23115>; else goto <D.23113>;
      <D.23115>:
      D.23108 = method->klass;
      D.23116 = D.23108->image;
      D.23117 = BIT_FIELD_REF <*D.23116, 8, 128>;
      D.23118 = D.23117 & 8;
      if (D.23118 != 0) goto <D.23119>; else goto <D.23113>;
      <D.23119>:
      D.23108 = method->klass;
      D.23120 = BIT_FIELD_REF <*D.23108, 8, 160>;
      D.23121 = D.23120 & 128;
      if (D.23121 == 0) goto <D.23122>; else goto <D.23113>;
      <D.23122>:
      D.23107 = context->method_inst;
      D.23123 = mono_method_get_generic_container (method);
      D.23124 = D.23123->context.method_inst;
      if (D.23107 == D.23124) goto <D.23125>; else goto <D.23113>;
      <D.23125>:
      iftmp.56 = 1;
      goto <D.23114>;
      <D.23113>:
      iftmp.56 = 0;
      <D.23114>:
      is_mb_open = iftmp.56;
      iresult = monoeg_malloc0 (48);
      iresult->context = *context;
      iresult->declaring = method;
      D.23126 = (unsigned char) is_mb_open;
      D.23127 = (<unnamed-unsigned:1>) D.23126;
      iresult->method.method.is_mb_open = D.23127;
      D.23107 = context->method_inst;
      if (D.23107 == 0B) goto <D.23128>; else goto <D.23129>;
      <D.23128>:
      D.23100 = BIT_FIELD_REF <*method, 8, 168>;
      D.23105 = D.23100 & 8;
      if (D.23105 != 0) goto <D.23130>; else goto <D.23131>;
      <D.23130>:
      D.23132 = mono_method_get_generic_container (method);
      D.23133 = D.23132->context.method_inst;
      iresult->context.method_inst = D.23133;
      <D.23131>:
      <D.23129>:
      D.23111 = context->class_inst;
      if (D.23111 == 0B) goto <D.23134>; else goto <D.23135>;
      <D.23134>:
      D.23136 = iresult->declaring;
      D.23137 = D.23136->klass;
      D.23138 = D.23137->generic_class;
      D.23139 = D.23138 != 0B;
      D.23140 = (long int) D.23139;
      D.23141 = __builtin_expect (D.23140, 0);
      if (D.23141 != 0) goto <D.23142>; else goto <D.23143>;
      <D.23142>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "class.c", 1059, "!iresult->declaring->klass->generic_class");
      <D.23143>:
      D.23136 = iresult->declaring;
      D.23137 = D.23136->klass;
      D.23144 = D.23137->generic_container;
      if (D.23144 != 0B) goto <D.23145>; else goto <D.23146>;
      <D.23145>:
      D.23136 = iresult->declaring;
      D.23137 = D.23136->klass;
      D.23144 = D.23137->generic_container;
      D.23147 = D.23144->context.class_inst;
      iresult->context.class_inst = D.23147;
      goto <D.23148>;
      <D.23146>:
      D.23136 = iresult->declaring;
      D.23137 = D.23136->klass;
      D.23138 = D.23137->generic_class;
      if (D.23138 != 0B) goto <D.23149>; else goto <D.23150>;
      <D.23149>:
      D.23136 = iresult->declaring;
      D.23137 = D.23136->klass;
      D.23138 = D.23137->generic_class;
      D.23151 = D.23138->context.class_inst;
      iresult->context.class_inst = D.23151;
      <D.23150>:
      <D.23148>:
      <D.23135>:
      mono_loader_lock ();
      cached = mono_method_inflated_lookup (iresult, 0);
      if (cached != 0B) goto <D.23152>; else goto <D.23153>;
      <D.23152>:
      mono_loader_unlock ();
      monoeg_g_free (iresult);
      D.23096 = cached;
      return D.23096;
      <D.23153>:
      D.23154 = mono_stats.inflated_method_count;
      D.23155 = D.23154 + 1;
      mono_stats.inflated_method_count = D.23155;
      inflated_methods_size.57 = inflated_methods_size;
      inflated_methods_size.58 = inflated_methods_size.57 + 48;
      inflated_methods_size = inflated_methods_size.58;
      sig = mono_method_signature (method);
      if (sig == 0B) goto <D.23158>; else goto <D.23159>;
      <D.23158>:
      {
        char * name;

        D.23108 = method->klass;
        name = mono_type_get_full_name (D.23108);
        D.23160 = method->name;
        D.23108 = method->klass;
        D.23116 = D.23108->image;
        mono_error_set_bad_image (error, D.23116, "Could not resolve signature of method %s:%s", name, D.23160);
        monoeg_g_free (name);
        goto fail;
      }
      <D.23159>:
      D.23161 = BIT_FIELD_REF <*sig, 8, 88>;
      D.23162 = D.23161 & 1;
      if (D.23162 != 0) goto <D.23163>; else goto <D.23164>;
      <D.23163>:
      D.23165 = &iresult->method.pinvoke;
      memcpy (D.23165, method, 32);
      goto <D.23166>;
      <D.23164>:
      D.23167 = &iresult->method.method;
      memcpy (D.23167, method, 24);
      <D.23166>:
      result = iresult;
      result->is_inflated = 1;
      result->is_generic = 0;
      result->sre_method = 0;
      result->signature = 0B;
      D.23126 = (unsigned char) is_mb_open;
      D.23127 = (<unnamed-unsigned:1>) D.23126;
      result->is_mb_open = D.23127;
      D.23107 = context->method_inst;
      if (D.23107 == 0B) goto <D.23168>; else goto <D.23169>;
      <D.23168>:
      {
        struct MonoGenericContainer * generic_container;

        generic_container = mono_method_get_generic_container (method);
        if (generic_container != 0B) goto <D.23170>; else goto <D.23171>;
        <D.23170>:
        result->is_generic = 1;
        mono_method_set_generic_container (result, generic_container);
        <D.23171>:
      }
      <D.23169>:
      if (klass_hint == 0B) goto <D.23172>; else goto <D.23174>;
      <D.23174>:
      D.23175 = klass_hint->generic_class;
      if (D.23175 == 0B) goto <D.23172>; else goto <D.23176>;
      <D.23176>:
      D.23175 = klass_hint->generic_class;
      D.23177 = D.23175->container_class;
      D.23108 = method->klass;
      if (D.23177 != D.23108) goto <D.23172>; else goto <D.23178>;
      <D.23178>:
      D.23175 = klass_hint->generic_class;
      D.23179 = D.23175->context.class_inst;
      D.23111 = context->class_inst;
      if (D.23179 != D.23111) goto <D.23172>; else goto <D.23173>;
      <D.23172>:
      klass_hint = 0B;
      <D.23173>:
      D.23108 = method->klass;
      D.23109 = D.23108->generic_container;
      if (D.23109 != 0B) goto <D.23180>; else goto <D.23181>;
      <D.23180>:
      result->klass = klass_hint;
      <D.23181>:
      D.23182 = result->klass;
      if (D.23182 == 0B) goto <D.23183>; else goto <D.23184>;
      <D.23183>:
      {
        struct MonoType * inflated;

        D.23108 = method->klass;
        D.23185 = &D.23108->byval_arg;
        inflated = inflate_generic_type (0B, D.23185, context, error);
        D.23186 = mono_error_ok (error);
        if (D.23186 == 0) goto fail; else goto <D.23187>;
        <D.23187>:
        if (inflated != 0B) goto <D.23189>; else goto <D.23190>;
        <D.23189>:
        iftmp.59 = mono_class_from_mono_type (inflated);
        goto <D.23191>;
        <D.23190>:
        iftmp.59 = method->klass;
        <D.23191>:
        result->klass = iftmp.59;
        if (inflated != 0B) goto <D.23192>; else goto <D.23193>;
        <D.23192>:
        mono_metadata_free_type (inflated);
        <D.23193>:
      }
      <D.23184>:
      mono_method_inflated_lookup (iresult, 1);
      mono_loader_unlock ();
      D.23096 = result;
      return D.23096;
      fail:
      mono_loader_unlock ();
      monoeg_g_free (iresult);
      D.23096 = 0B;
      return D.23096;
    }
  finally
    {
      tmp_context = {CLOBBER};
    }
}


inflate_generic_context (struct MonoGenericContext * context, struct MonoGenericContext * inflate_with, struct MonoError * error)
{
  struct MonoGenericInst * D.23197;
  int D.23200;
  struct MonoGenericInst * D.23202;
  int D.23205;
  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.23197 = context->class_inst;
      if (D.23197 != 0B) goto <D.23198>; else goto <D.23199>;
      <D.23198>:
      D.23197 = context->class_inst;
      class_inst = mono_metadata_inflate_generic_inst (D.23197, inflate_with, error);
      D.23200 = mono_error_ok (error);
      if (D.23200 == 0) goto fail; else goto <D.23201>;
      <D.23201>:
      <D.23199>:
      D.23202 = context->method_inst;
      if (D.23202 != 0B) goto <D.23203>; else goto <D.23204>;
      <D.23203>:
      D.23202 = context->method_inst;
      method_inst = mono_metadata_inflate_generic_inst (D.23202, inflate_with, error);
      D.23205 = mono_error_ok (error);
      if (D.23205 == 0) goto fail; else goto <D.23206>;
      <D.23206>:
      <D.23204>:
      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.23209;

  D.23209 = method;
  return D.23209;
}


mono_method_get_context_general (struct MonoMethod * method, gboolean uninflated)
{
  unsigned char D.23211;
  unsigned char D.23212;
  struct MonoGenericContext * D.23215;
  unsigned char D.23218;
  struct MonoGenericContainer * D.23221;
  struct MonoClass * D.23222;
  struct MonoGenericContainer * D.23223;

  D.23211 = BIT_FIELD_REF <*method, 8, 168>;
  D.23212 = D.23211 & 16;
  if (D.23212 != 0) goto <D.23213>; else goto <D.23214>;
  <D.23213>:
  {
    struct MonoMethodInflated * imethod;

    imethod = method;
    D.23215 = &imethod->context;
    return D.23215;
  }
  <D.23214>:
  if (uninflated == 0) goto <D.23216>; else goto <D.23217>;
  <D.23216>:
  D.23215 = 0B;
  return D.23215;
  <D.23217>:
  D.23211 = BIT_FIELD_REF <*method, 8, 168>;
  D.23218 = D.23211 & 8;
  if (D.23218 != 0) goto <D.23219>; else goto <D.23220>;
  <D.23219>:
  D.23221 = mono_method_get_generic_container (method);
  D.23215 = &D.23221->context;
  return D.23215;
  <D.23220>:
  D.23222 = method->klass;
  D.23223 = D.23222->generic_container;
  if (D.23223 != 0B) goto <D.23224>; else goto <D.23225>;
  <D.23224>:
  D.23222 = method->klass;
  D.23223 = D.23222->generic_container;
  D.23215 = &D.23223->context;
  return D.23215;
  <D.23225>:
  D.23215 = 0B;
  return D.23215;
}


mono_method_get_context (struct MonoMethod * method)
{
  struct MonoGenericContext * D.23227;

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


mono_method_get_generic_container (struct MonoMethod * method)
{
  unsigned char D.23229;
  unsigned char D.23230;
  struct MonoGenericContainer * D.23233;
  struct MonoClass * D.23234;
  struct MonoImage * D.23235;
  _Bool D.23236;
  long int D.23237;
  long int D.23238;
  struct MonoGenericContainer * container;

  D.23229 = BIT_FIELD_REF <*method, 8, 168>;
  D.23230 = D.23229 & 8;
  if (D.23230 == 0) goto <D.23231>; else goto <D.23232>;
  <D.23231>:
  D.23233 = 0B;
  return D.23233;
  <D.23232>:
  D.23234 = method->klass;
  D.23235 = D.23234->image;
  container = mono_image_property_lookup (D.23235, method, 0);
  D.23236 = container == 0B;
  D.23237 = (long int) D.23236;
  D.23238 = __builtin_expect (D.23237, 0);
  if (D.23238 != 0) goto <D.23239>; else goto <D.23240>;
  <D.23239>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "class.c", 1216, "container");
  <D.23240>:
  D.23233 = container;
  return D.23233;
}


mono_method_set_generic_container (struct MonoMethod * method, struct MonoGenericContainer * container)
{
  unsigned char D.23242;
  unsigned char D.23243;
  _Bool D.23244;
  long int D.23245;
  long int D.23246;
  struct MonoClass * D.23249;
  struct MonoImage * D.23250;

  D.23242 = BIT_FIELD_REF <*method, 8, 168>;
  D.23243 = D.23242 & 8;
  D.23244 = D.23243 == 0;
  D.23245 = (long int) D.23244;
  D.23246 = __builtin_expect (D.23245, 0);
  if (D.23246 != 0) goto <D.23247>; else goto <D.23248>;
  <D.23247>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "class.c", 1230, "method->is_generic");
  <D.23248>:
  D.23249 = method->klass;
  D.23250 = D.23249->image;
  mono_image_property_insert (D.23250, method, 0, container);
}


mono_class_setup_fields_locking (struct MonoClass * class)
{
  unsigned char D.23251;
  unsigned char D.23252;

  D.23251 = BIT_FIELD_REF <*class, 8, 192>;
  D.23252 = D.23251 & 32;
  if (D.23252 != 0) goto <D.23253>; else goto <D.23254>;
  <D.23253>:
  return;
  <D.23254>:
  mono_loader_lock ();
  mono_class_setup_fields (class);
  mono_loader_unlock ();
}


mono_class_setup_fields (struct MonoClass * class)
{
  unsigned int D.23256;
  struct MonoClass * iftmp.60;
  struct MonoGenericClass * D.23258;
  unsigned char D.23262;
  unsigned char D.23263;
  struct MonoClass * D.23268;
  struct MonoImage * D.23269;
  unsigned char D.23270;
  unsigned char D.23271;
  unsigned char D.23274;
  unsigned char D.23275;
  unsigned int D.23278;
  unsigned char D.23281;
  unsigned char D.23284;
  struct MonoClass * D.23287;
  unsigned char D.23290;
  unsigned char D.23291;
  unsigned char D.23294;
  int D.23297;
  int D.23298;
  int D.23299;
  unsigned char D.23300;
  <unnamed-unsigned:1> D.23301;
  unsigned char D.23302;
  <unnamed-unsigned:1> D.23303;
  unsigned char D.23304;
  unsigned char D.23305;
  <unnamed-unsigned:1> D.23306;
  <unnamed-unsigned:1> D.23307;
  unsigned int D.23309;
  struct MonoImage * D.23310;
  unsigned int D.23311;
  unsigned int packing_size.61;
  unsigned int D.23315;
  const char * D.23318;
  unsigned char D.23319;
  <unnamed-unsigned:4> D.23320;
  unsigned int D.23321;
  unsigned int real_size.62;
  unsigned int real_size.63;
  unsigned int D.23330;
  int D.23331;
  unsigned char D.23332;
  <unnamed-unsigned:1> D.23333;
  struct MonoGenericContainer * D.23336;
  _Bool D.23342;
  long int D.23343;
  long int D.23344;
  unsigned int D.23347;
  unsigned int i.64;
  unsigned int D.23349;
  struct MonoClassField * D.23350;
  unsigned int i.65;
  unsigned int D.23352;
  struct MonoType * D.23353;
  int D.23356;
  const char * D.23361;
  char * D.23362;
  _Bool D.23363;
  long int D.23364;
  long int D.23365;
  short unsigned int D.23368;
  int D.23369;
  int D.23370;
  int D.18821;
  int iftmp.66;
  int D.18820;
  const char[9] * D.23376;
  unsigned char D.23377;
  int D.23378;
  unsigned char D.23379;
  int D.23380;
  _Bool D.23381;
  _Bool D.23382;
  _Bool D.23383;
  const unsigned char * D.23386;
  unsigned char D.23387;
  int D.23388;
  const unsigned char * D.23389;
  unsigned char D.23390;
  int D.23391;
  _Bool D.23392;
  _Bool D.23393;
  const unsigned char * D.23396;
  unsigned char D.23397;
  int D.23398;
  const unsigned char * D.23399;
  unsigned char D.23400;
  int D.23401;
  _Bool D.23402;
  _Bool D.23403;
  const unsigned char * D.23406;
  unsigned char D.23407;
  int D.23408;
  const unsigned char * D.23409;
  unsigned char D.23410;
  int D.23411;
  const char * D.23413;
  struct MonoClassField * D.23418;
  int D.23419;
  unsigned int idx.67;
  unsigned int offset.68;
  int offset.69;
  int D.23426;
  int D.23429;
  gchar * D.23432;
  gchar * D.23435;
  unsigned char D.23443;
  unsigned char D.23444;
  int D.23446;
  unsigned char D.23449;
  unsigned char D.23455;
  unsigned char D.23456;
  unsigned char D.23457;
  unsigned char D.23458;
  struct MonoClass * D.23463;
  struct MonoClass * D.23464;
  <unnamed-unsigned:1> D.23465;
  int D.23466;
  struct MonoClass * D.23469;
  struct MonoType * D.23474;
  unsigned char D.23481;
  unsigned char D.23484;
  unsigned int D.23487;
  unsigned int D.23488;
  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.23256 = class->flags;
      layout = D.23256 & 24;
      blittable = 1;
      real_size = 0;
      packing_size = 0;
      container = 0B;
      D.23258 = class->generic_class;
      if (D.23258 != 0B) goto <D.23259>; else goto <D.23260>;
      <D.23259>:
      iftmp.60 = mono_class_get_generic_type_definition (class);
      goto <D.23261>;
      <D.23260>:
      iftmp.60 = 0B;
      <D.23261>:
      gtd = iftmp.60;
      D.23262 = BIT_FIELD_REF <*class, 8, 192>;
      D.23263 = D.23262 & 64;
      if (D.23263 != 0) goto <D.23264>; else goto <D.23265>;
      <D.23264>:
      return;
      <D.23265>:
      D.23258 = class->generic_class;
      if (D.23258 != 0B) goto <D.23266>; else goto <D.23267>;
      <D.23266>:
      D.23258 = class->generic_class;
      D.23268 = D.23258->container_class;
      D.23269 = D.23268->image;
      D.23270 = BIT_FIELD_REF <*D.23269, 8, 128>;
      D.23271 = D.23270 & 8;
      if (D.23271 != 0) goto <D.23272>; else goto <D.23273>;
      <D.23272>:
      D.23258 = class->generic_class;
      D.23268 = D.23258->container_class;
      D.23274 = BIT_FIELD_REF <*D.23268, 8, 160>;
      D.23275 = D.23274 & 128;
      if (D.23275 == 0) goto <D.23276>; else goto <D.23277>;
      <D.23276>:
      return;
      <D.23277>:
      <D.23273>:
      <D.23267>:
      mono_class_setup_basic_field_info (class);
      D.23278 = class->field.count;
      top = (int) D.23278;
      if (gtd != 0B) goto <D.23279>; else goto <D.23280>;
      <D.23279>:
      mono_class_setup_fields (gtd);
      D.23281 = gtd->exception_type;
      if (D.23281 != 0) goto <D.23282>; else goto <D.23283>;
      <D.23282>:
      mono_class_set_failure (class, 7, 0B);
      return;
      <D.23283>:
      <D.23280>:
      class->instance_size = 0;
      D.23284 = class->rank;
      if (D.23284 == 0) goto <D.23285>; else goto <D.23286>;
      <D.23285>:
      class->sizes.class_size = 0;
      <D.23286>:
      D.23287 = class->parent;
      if (D.23287 != 0B) goto <D.23288>; else goto <D.23289>;
      <D.23288>:
      D.23287 = class->parent;
      mono_class_init (D.23287);
      D.23287 = class->parent;
      D.23290 = BIT_FIELD_REF <*D.23287, 8, 160>;
      D.23291 = D.23290 & 4;
      if (D.23291 == 0) goto <D.23292>; else goto <D.23293>;
      <D.23292>:
      D.23287 = class->parent;
      mono_class_setup_fields (D.23287);
      D.23287 = class->parent;
      D.23294 = D.23287->exception_type;
      if (D.23294 != 0) goto <D.23295>; else goto <D.23296>;
      <D.23295>:
      mono_class_set_failure (class, 7, 0B);
      return;
      <D.23296>:
      <D.23293>:
      D.23297 = class->instance_size;
      D.23287 = class->parent;
      D.23298 = D.23287->instance_size;
      D.23299 = D.23297 + D.23298;
      class->instance_size = D.23299;
      D.23287 = class->parent;
      D.23300 = D.23287->min_align;
      class->min_align = D.23300;
      D.23301 = class->has_references;
      D.23302 = (unsigned char) D.23301;
      D.23287 = class->parent;
      D.23303 = D.23287->has_references;
      D.23304 = (unsigned char) D.23303;
      D.23305 = D.23302 | D.23304;
      D.23306 = (<unnamed-unsigned:1>) D.23305;
      class->has_references = D.23306;
      D.23287 = class->parent;
      D.23307 = D.23287->blittable;
      blittable = (int) D.23307;
      goto <D.23308>;
      <D.23289>:
      class->instance_size = 8;
      class->min_align = 1;
      <D.23308>:
      D.23309 = class->type_token;
      D.23310 = class->image;
      D.23311 = mono_metadata_packing_from_typedef (D.23310, D.23309, &packing_size, &real_size);
      explicit_size = (gboolean) D.23311;
      if (explicit_size != 0) goto <D.23312>; else goto <D.23313>;
      <D.23312>:
      packing_size.61 = packing_size;
      D.23315 = packing_size.61 & 4294967280;
      if (D.23315 != 0) goto <D.23316>; else goto <D.23317>;
      <D.23316>:
      {
        char * err_msg;

        packing_size.61 = packing_size;
        D.23318 = class->name;
        err_msg = monoeg_g_strdup_printf ("Could not load struct \'%s\' with packing size %d >= 16", D.23318, packing_size.61);
        mono_class_set_failure (class, 7, err_msg);
        return;
      }
      <D.23317>:
      packing_size.61 = packing_size;
      D.23319 = (unsigned char) packing_size.61;
      D.23320 = (<unnamed-unsigned:4>) D.23319;
      class->packing_size = D.23320;
      D.23297 = class->instance_size;
      D.23321 = (unsigned int) D.23297;
      real_size.62 = real_size;
      real_size.63 = D.23321 + real_size.62;
      real_size = real_size.63;
      <D.23313>:
      if (top == 0) goto <D.23324>; else goto <D.23325>;
      <D.23324>:
      if (explicit_size != 0) goto <D.23326>; else goto <D.23327>;
      <D.23326>:
      real_size.62 = real_size;
      if (real_size.62 != 0) goto <D.23328>; else goto <D.23329>;
      <D.23328>:
      D.23297 = class->instance_size;
      D.23321 = (unsigned int) D.23297;
      real_size.62 = real_size;
      D.23330 = MAX_EXPR <D.23321, real_size.62>;
      D.23331 = (int) D.23330;
      class->instance_size = D.23331;
      <D.23329>:
      <D.23327>:
      D.23332 = (unsigned char) blittable;
      D.23333 = (<unnamed-unsigned:1>) D.23332;
      class->blittable = D.23333;
      mono_memory_barrier ();
      class->size_inited = 1;
      class->fields_inited = 1;
      class->setup_fields_called = 1;
      return;
      <D.23325>:
      if (layout == 0) goto <D.23334>; else goto <D.23335>;
      <D.23334>:
      blittable = 0;
      <D.23335>:
      class->setup_fields_called = 1;
      D.23336 = class->generic_container;
      if (D.23336 != 0B) goto <D.23337>; else goto <D.23338>;
      <D.23337>:
      container = class->generic_container;
      goto <D.23339>;
      <D.23338>:
      if (gtd != 0B) goto <D.23340>; else goto <D.23341>;
      <D.23340>:
      container = gtd->generic_container;
      D.23342 = container == 0B;
      D.23343 = (long int) D.23342;
      D.23344 = __builtin_expect (D.23343, 0);
      if (D.23344 != 0) goto <D.23345>; else goto <D.23346>;
      <D.23345>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "class.c", 1567, "container");
      <D.23346>:
      <D.23341>:
      <D.23339>:
      i = 0;
      goto <D.18830>;
      <D.18829>:
      {
        int idx;

        D.23347 = class->field.first;
        i.64 = (unsigned int) i;
        D.23349 = D.23347 + i.64;
        idx = (int) D.23349;
        D.23350 = class->fields;
        i.65 = (unsigned int) i;
        D.23352 = i.65 * 16;
        field = D.23350 + D.23352;
        field->parent = class;
        D.23353 = field->type;
        if (D.23353 == 0B) goto <D.23354>; else goto <D.23355>;
        <D.23354>:
        mono_field_resolve_type (field, &error);
        D.23356 = mono_error_ok (&error);
        if (D.23356 == 0) goto <D.23357>; else goto <D.23358>;
        <D.23357>:
        mono_error_cleanup (&error);
        return;
        <D.23358>:
        D.23353 = field->type;
        if (D.23353 == 0B) goto <D.23359>; else goto <D.23360>;
        <D.23359>:
        D.23361 = field->name;
        D.23362 = mono_type_get_full_name (class);
        monoeg_g_log (0B, 4, "could not resolve %s:%s\n", D.23362, D.23361);
        <D.18812>:
        goto <D.18812>;
        <D.23360>:
        D.23353 = field->type;
        D.23363 = D.23353 == 0B;
        D.23364 = (long int) D.23363;
        D.23365 = __builtin_expect (D.23364, 0);
        if (D.23365 != 0) goto <D.23366>; else goto <D.23367>;
        <D.23366>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "class.c", 1588, "field->type");
        <D.23367>:
        <D.23355>:
        D.23353 = field->type;
        D.23368 = D.23353->attrs;
        D.23369 = (int) D.23368;
        D.23370 = D.23369 & 1536;
        if (D.23370 != 0) goto <D.23371>; else goto <D.23372>;
        <D.23371>:
        {
          size_t __s1_len;
          size_t __s2_len;

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

            __s2 = mono_field_get_name (field);
            D.23376 = "_Deleted";
            D.23377 = MEM[(const unsigned char *)D.23376];
            D.23378 = (int) D.23377;
            D.23379 = *__s2;
            D.23380 = (int) D.23379;
            __result = D.23378 - D.23380;
            {
              D.23381 = __s2_len != 0;
              D.23382 = __result == 0;
              D.23383 = D.23381 & D.23382;
              if (D.23383 != 0) goto <D.23384>; else goto <D.23385>;
              <D.23384>:
              D.23386 = &MEM[(void *)"_Deleted" + 1B];
              D.23387 = *D.23386;
              D.23388 = (int) D.23387;
              D.23389 = __s2 + 1;
              D.23390 = *D.23389;
              D.23391 = (int) D.23390;
              __result = D.23388 - D.23391;
              D.23392 = __s2_len > 1;
              D.23382 = __result == 0;
              D.23393 = D.23392 & D.23382;
              if (D.23393 != 0) goto <D.23394>; else goto <D.23395>;
              <D.23394>:
              D.23396 = &MEM[(void *)"_Deleted" + 2B];
              D.23397 = *D.23396;
              D.23398 = (int) D.23397;
              D.23399 = __s2 + 2;
              D.23400 = *D.23399;
              D.23401 = (int) D.23400;
              __result = D.23398 - D.23401;
              D.23402 = __s2_len > 2;
              D.23382 = __result == 0;
              D.23403 = D.23402 & D.23382;
              if (D.23403 != 0) goto <D.23404>; else goto <D.23405>;
              <D.23404>:
              D.23406 = &MEM[(void *)"_Deleted" + 3B];
              D.23407 = *D.23406;
              D.23408 = (int) D.23407;
              D.23409 = __s2 + 3;
              D.23410 = *D.23409;
              D.23411 = (int) D.23410;
              __result = D.23408 - D.23411;
              <D.23405>:
              <D.23395>:
              <D.23385>:
            }
            D.18820 = __result;
          }
          iftmp.66 = -D.18820;
          goto <D.23412>;
          <D.23375>:
          D.23413 = mono_field_get_name (field);
          iftmp.66 = __builtin_strcmp (D.23413, "_Deleted");
          <D.23412>:
          D.18821 = iftmp.66;
        }
        if (D.18821 == 0) goto <D.23414>; else goto <D.23415>;
        <D.23414>:
        // predicted unlikely by continue predictor.
        goto <D.18822>;
        <D.23415>:
        <D.23372>:
        if (gtd != 0B) goto <D.23416>; else goto <D.23417>;
        <D.23416>:
        {
          struct MonoClassField * gfield;

          D.23418 = gtd->fields;
          i.65 = (unsigned int) i;
          D.23352 = i.65 * 16;
          gfield = D.23418 + D.23352;
          D.23419 = gfield->offset;
          field->offset = D.23419;
        }
        goto <D.23420>;
        <D.23417>:
        if (layout == 16) goto <D.23421>; else goto <D.23422>;
        <D.23421>:
        {
          guint32 offset;

          try
            {
              idx.67 = (unsigned int) idx;
              mono_metadata_field_info (m, idx.67, &offset, 0B, 0B);
              offset.68 = offset;
              offset.69 = (int) offset.68;
              field->offset = offset.69;
              D.23426 = field->offset;
              if (D.23426 == -1) goto <D.23427>; else goto <D.23428>;
              <D.23427>:
              D.23353 = field->type;
              D.23368 = D.23353->attrs;
              D.23369 = (int) D.23368;
              D.23429 = D.23369 & 16;
              if (D.23429 == 0) goto <D.23430>; else goto <D.23431>;
              <D.23430>:
              D.23361 = field->name;
              D.23432 = monoeg_g_strdup_printf ("Missing field layout info for %s", D.23361);
              mono_class_set_failure (class, 7, D.23432);
              goto <D.18825>;
              <D.23431>:
              <D.23428>:
              D.23426 = field->offset;
              if (D.23426 < -1) goto <D.23433>; else goto <D.23434>;
              <D.23433>:
              D.23361 = field->name;
              D.23426 = field->offset;
              D.23435 = monoeg_g_strdup_printf ("Invalid negative field offset %d for %s", D.23426, D.23361);
              mono_class_set_failure (class, 7, D.23435);
              goto <D.18825>;
              <D.23434>:
            }
          finally
            {
              offset = {CLOBBER};
            }
        }
        <D.23422>:
        <D.23420>:
        if (blittable != 0) goto <D.23436>; else goto <D.23437>;
        <D.23436>:
        D.23353 = field->type;
        D.23368 = D.23353->attrs;
        D.23369 = (int) D.23368;
        D.23429 = D.23369 & 16;
        if (D.23429 == 0) goto <D.23438>; else goto <D.23439>;
        <D.23438>:
        D.23353 = field->type;
        D.23443 = BIT_FIELD_REF <*D.23353, 8, 56>;
        D.23444 = D.23443 & 64;
        if (D.23444 != 0) goto <D.23440>; else goto <D.23445>;
        <D.23445>:
        D.23353 = field->type;
        D.23446 = mono_type_is_reference (D.23353);
        if (D.23446 != 0) goto <D.23440>; else goto <D.23441>;
        <D.23440>:
        blittable = 0;
        goto <D.23442>;
        <D.23441>:
        {
          struct MonoClass * field_class;

          D.23353 = field->type;
          field_class = mono_class_from_mono_type (D.23353);
          if (field_class != 0B) goto <D.23447>; else goto <D.23448>;
          <D.23447>:
          mono_class_setup_fields (field_class);
          D.23449 = field_class->exception_type;
          if (D.23449 != 0) goto <D.23450>; else goto <D.23451>;
          <D.23450>:
          mono_class_set_failure (class, 7, 0B);
          goto <D.18825>;
          <D.23451>:
          <D.23448>:
          if (field_class == 0B) goto <D.23452>; else goto <D.23454>;
          <D.23454>:
          D.23455 = BIT_FIELD_REF <*field_class, 8, 160>;
          D.23456 = D.23455 & 32;
          if (D.23456 == 0) goto <D.23452>; else goto <D.23453>;
          <D.23452>:
          blittable = 0;
          <D.23453>:
        }
        <D.23442>:
        <D.23439>:
        <D.23437>:
        D.23457 = BIT_FIELD_REF <*class, 8, 160>;
        D.23458 = D.23457 & 16;
        if (D.23458 != 0) goto <D.23459>; else goto <D.23460>;
        <D.23459>:
        D.23353 = field->type;
        D.23368 = D.23353->attrs;
        D.23369 = (int) D.23368;
        D.23429 = D.23369 & 16;
        if (D.23429 == 0) goto <D.23461>; else goto <D.23462>;
        <D.23461>:
        D.23353 = field->type;
        D.23463 = mono_class_from_mono_type (D.23353);
        class->element_class = D.23463;
        D.23464 = class->element_class;
        class->cast_class = D.23464;
        D.23464 = class->element_class;
        D.23465 = D.23464->blittable;
        blittable = (int) D.23465;
        <D.23462>:
        <D.23460>:
        D.23353 = field->type;
        D.23466 = mono_type_has_exceptions (D.23353);
        if (D.23466 != 0) goto <D.23467>; else goto <D.23468>;
        <D.23467>:
        {
          char * class_name;
          char * type_name;

          class_name = mono_type_get_full_name (class);
          D.23353 = field->type;
          type_name = mono_type_full_name (D.23353);
          mono_class_set_failure (class, 7, 0B);
          D.23361 = field->name;
          monoeg_g_log (0B, 16, "Invalid type %s for instance field %s:%s", type_name, class_name, D.23361);
          monoeg_g_free (class_name);
          monoeg_g_free (type_name);
          goto <D.18825>;
        }
        <D.23468>:
      }
      <D.18822>:
      i = i + 1;
      <D.18830>:
      if (i < top) goto <D.18829>; else goto <D.18825>;
      <D.18825>:
      D.23469 = mono_defaults.string_class;
      if (D.23469 == class) goto <D.23470>; else goto <D.23471>;
      <D.23470>:
      blittable = 0;
      <D.23471>:
      D.23332 = (unsigned char) blittable;
      D.23333 = (<unnamed-unsigned:1>) D.23332;
      class->blittable = D.23333;
      D.23457 = BIT_FIELD_REF <*class, 8, 160>;
      D.23458 = D.23457 & 16;
      if (D.23458 != 0) goto <D.23472>; else goto <D.23473>;
      <D.23472>:
      D.23474 = mono_class_enum_basetype (class);
      if (D.23474 == 0B) goto <D.23475>; else goto <D.23476>;
      <D.23475>:
      mono_class_set_failure (class, 7, 0B);
      return;
      <D.23476>:
      <D.23473>:
      if (explicit_size != 0) goto <D.23477>; else goto <D.23478>;
      <D.23477>:
      real_size.62 = real_size;
      if (real_size.62 != 0) goto <D.23479>; else goto <D.23480>;
      <D.23479>:
      D.23297 = class->instance_size;
      D.23321 = (unsigned int) D.23297;
      real_size.62 = real_size;
      D.23330 = MAX_EXPR <D.23321, real_size.62>;
      D.23331 = (int) D.23330;
      class->instance_size = D.23331;
      <D.23480>:
      <D.23478>:
      D.23481 = class->exception_type;
      if (D.23481 != 0) goto <D.23482>; else goto <D.23483>;
      <D.23482>:
      return;
      <D.23483>:
      mono_class_layout_fields (class);
      D.23457 = BIT_FIELD_REF <*class, 8, 160>;
      D.23484 = D.23457 & 8;
      if (D.23484 != 0) goto <D.23485>; else goto <D.23486>;
      <D.23485>:
      D.23297 = class->instance_size;
      D.23487 = (unsigned int) D.23297;
      D.23488 = D.23487 + 4294967295;
      if (D.23488 > 1048583) goto <D.23489>; else goto <D.23490>;
      <D.23489>:
      mono_class_set_failure (class, 7, 0B);
      <D.23490>:
      <D.23486>:
      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.23496;
  struct MonoClass * iftmp.70;
  struct MonoGenericClass * D.23500;
  unsigned int D.23504;
  struct MonoClass * D.23507;
  struct MonoImage * D.23508;
  unsigned char D.23509;
  unsigned char D.23510;
  unsigned char D.23513;
  unsigned char D.23514;
  unsigned int D.23519;
  unsigned int D.23520;
  unsigned int top.71;
  unsigned int D.23522;
  int D.23523;
  void * D.23524;
  unsigned int i.72;
  unsigned int D.23526;
  struct MonoClassField * D.23529;
  struct MonoClassField * D.23530;
  const char * D.23531;
  unsigned int D.23533;
  unsigned int i.73;
  unsigned int D.23535;
  const char * D.23536;
  struct MonoClassField * field;
  struct MonoClass * gtd;
  struct MonoImage * image;
  int i;
  int top;

  D.23496 = class->fields;
  if (D.23496 != 0B) goto <D.23497>; else goto <D.23498>;
  <D.23497>:
  return;
  <D.23498>:
  D.23500 = class->generic_class;
  if (D.23500 != 0B) goto <D.23501>; else goto <D.23502>;
  <D.23501>:
  iftmp.70 = mono_class_get_generic_type_definition (class);
  goto <D.23503>;
  <D.23502>:
  iftmp.70 = 0B;
  <D.23503>:
  gtd = iftmp.70;
  image = class->image;
  D.23504 = class->field.count;
  top = (int) D.23504;
  D.23500 = class->generic_class;
  if (D.23500 != 0B) goto <D.23505>; else goto <D.23506>;
  <D.23505>:
  D.23500 = class->generic_class;
  D.23507 = D.23500->container_class;
  D.23508 = D.23507->image;
  D.23509 = BIT_FIELD_REF <*D.23508, 8, 128>;
  D.23510 = D.23509 & 8;
  if (D.23510 != 0) goto <D.23511>; else goto <D.23512>;
  <D.23511>:
  D.23500 = class->generic_class;
  D.23507 = D.23500->container_class;
  D.23513 = BIT_FIELD_REF <*D.23507, 8, 160>;
  D.23514 = D.23513 & 128;
  if (D.23514 == 0) goto <D.23515>; else goto <D.23516>;
  <D.23515>:
  return;
  <D.23516>:
  <D.23512>:
  <D.23506>:
  if (gtd != 0B) goto <D.23517>; else goto <D.23518>;
  <D.23517>:
  mono_class_setup_basic_field_info (gtd);
  D.23519 = gtd->field.count;
  top = (int) D.23519;
  D.23520 = gtd->field.first;
  class->field.first = D.23520;
  D.23519 = gtd->field.count;
  class->field.count = D.23519;
  <D.23518>:
  top.71 = (unsigned int) top;
  D.23522 = top.71 * 16;
  D.23523 = (int) D.23522;
  D.23524 = mono_class_alloc0 (class, D.23523);
  class->fields = D.23524;
  i = 0;
  goto <D.18793>;
  <D.18792>:
  D.23496 = class->fields;
  i.72 = (unsigned int) i;
  D.23526 = i.72 * 16;
  field = D.23496 + D.23526;
  field->parent = class;
  if (gtd != 0B) goto <D.23527>; else goto <D.23528>;
  <D.23527>:
  D.23529 = gtd->fields;
  i.72 = (unsigned int) i;
  D.23526 = i.72 * 16;
  D.23530 = D.23529 + D.23526;
  D.23531 = mono_field_get_name (D.23530);
  field->name = D.23531;
  goto <D.23532>;
  <D.23528>:
  {
    int idx;
    guint32 name_idx;

    D.23533 = class->field.first;
    i.73 = (unsigned int) i;
    D.23535 = D.23533 + i.73;
    idx = (int) D.23535;
    name_idx = mono_metadata_decode_table_row_col (image, 4, idx, 1);
    D.23536 = mono_metadata_string_heap (image, name_idx);
    field->name = D.23536;
  }
  <D.23532>:
  i = i + 1;
  <D.18793>:
  if (i < top) goto <D.18792>; else goto <D.18794>;
  <D.18794>:
}


mono_class_alloc0 (struct MonoClass * class, int size)
{
  unsigned int size.74;
  void * D.23539;
  void * res;

  res = mono_class_alloc (class, size);
  size.74 = (unsigned int) size;
  memset (res, 0, size.74);
  D.23539 = res;
  return D.23539;
}


mono_class_alloc (struct MonoClass * class, int size)
{
  struct MonoGenericClass * D.23541;
  void * D.23544;
  unsigned int size.75;
  struct MonoImageSet * D.23546;
  struct MonoImage * D.23547;

  D.23541 = class->generic_class;
  if (D.23541 != 0B) goto <D.23542>; else goto <D.23543>;
  <D.23542>:
  size.75 = (unsigned int) size;
  D.23541 = class->generic_class;
  D.23546 = D.23541->owner;
  D.23544 = mono_image_set_alloc (D.23546, size.75);
  return D.23544;
  <D.23543>:
  size.75 = (unsigned int) size;
  D.23547 = class->image;
  D.23544 = mono_image_alloc (D.23547, size.75);
  return D.23544;
}


memset (void * __dest, int __ch, size_t __len)
{
  int D.23551;
  int D.23556;
  void * D.23558;
  unsigned int D.23559;

  D.23551 = __builtin_constant_p (__len);
  if (D.23551 != 0) goto <D.23552>; else goto <D.23553>;
  <D.23552>:
  if (__len == 0) goto <D.23554>; else goto <D.23555>;
  <D.23554>:
  D.23556 = __builtin_constant_p (__ch);
  if (D.23556 == 0) goto <D.23549>; else goto <D.23557>;
  <D.23557>:
  if (__ch != 0) goto <D.23549>; else goto <D.23550>;
  <D.23549>:
  __warn_memset_zero_len ();
  D.23558 = __dest;
  return D.23558;
  <D.23550>:
  <D.23555>:
  <D.23553>:
  D.23559 = __builtin_object_size (__dest, 0);
  D.23558 = __builtin___memset_chk (__dest, __ch, __len, D.23559);
  return D.23558;
}


mono_field_resolve_type (struct MonoClassField * field, struct MonoError * error)
{
  struct MonoClass * iftmp.76;
  struct MonoGenericClass * D.23562;
  int field.77;
  struct MonoClassField * D.23567;
  int D.23568;
  int D.23569;
  struct MonoClassField * D.23572;
  unsigned int field_idx.78;
  unsigned int D.23574;
  int D.23575;
  const char * D.23578;
  struct MonoGenericContext * D.23579;
  struct MonoType * D.23580;
  int D.23581;
  const char * D.23584;
  unsigned int D.23586;
  unsigned int field_idx.79;
  unsigned int D.23588;
  unsigned char D.23589;
  unsigned char D.23590;
  _Bool D.23591;
  long int D.23592;
  long int D.23593;
  struct MonoGenericContainer * D.23596;
  _Bool D.23602;
  long int D.23603;
  long int D.23604;
  unsigned int D.23607;
  int D.23608;
  const char * D.23611;
  const char * sig.80;
  const char * sig.81;
  char D.23614;
  _Bool D.23615;
  long int D.23616;
  long int D.23617;
  const char * D.23620;
  unsigned int D.23621;
  short int D.23622;
  int D.23623;
  struct MonoType * D.23624;
  struct MonoType * D.23625;
  gchar * D.23628;
  struct MonoClass * class;
  struct MonoImage * image;
  struct MonoClass * gtd;
  int field_idx;

  class = field->parent;
  image = class->image;
  D.23562 = class->generic_class;
  if (D.23562 != 0B) goto <D.23563>; else goto <D.23564>;
  <D.23563>:
  iftmp.76 = mono_class_get_generic_type_definition (class);
  goto <D.23565>;
  <D.23564>:
  iftmp.76 = 0B;
  <D.23565>:
  gtd = iftmp.76;
  field.77 = (int) field;
  D.23567 = class->fields;
  D.23568 = (int) D.23567;
  D.23569 = field.77 - D.23568;
  field_idx = D.23569 /[ex] 16;
  mono_error_init (error);
  if (gtd != 0B) goto <D.23570>; else goto <D.23571>;
  <D.23570>:
  {
    struct MonoClassField * gfield;
    struct MonoType * gtype;

    D.23572 = gtd->fields;
    field_idx.78 = (unsigned int) field_idx;
    D.23574 = field_idx.78 * 16;
    gfield = D.23572 + D.23574;
    gtype = mono_field_get_type_checked (gfield, error);
    D.23575 = mono_error_ok (error);
    if (D.23575 == 0) goto <D.23576>; else goto <D.23577>;
    <D.23576>:
    {
      char * err_msg;

      D.23578 = mono_error_get_message (error);
      err_msg = monoeg_g_strdup_printf ("Could not load field %d type due to: %s", field_idx, D.23578);
      mono_class_set_failure (class, 7, err_msg);
      monoeg_g_free (err_msg);
    }
    <D.23577>:
    D.23579 = mono_class_get_context (class);
    D.23580 = mono_class_inflate_generic_type_no_copy (image, gtype, D.23579, error);
    field->type = D.23580;
    D.23581 = mono_error_ok (error);
    if (D.23581 == 0) goto <D.23582>; else goto <D.23583>;
    <D.23582>:
    {
      char * err_msg;

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

    try
      {
        container = 0B;
        D.23586 = class->field.first;
        field_idx.79 = (unsigned int) field_idx;
        D.23588 = D.23586 + field_idx.79;
        idx = (int) D.23588;
        D.23589 = BIT_FIELD_REF <*image, 8, 128>;
        D.23590 = D.23589 & 8;
        D.23591 = D.23590 != 0;
        D.23592 = (long int) D.23591;
        D.23593 = __builtin_expect (D.23592, 0);
        if (D.23593 != 0) goto <D.23594>; else goto <D.23595>;
        <D.23594>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "class.c", 10119, "!image->dynamic");
        <D.23595>:
        D.23596 = class->generic_container;
        if (D.23596 != 0B) goto <D.23597>; else goto <D.23598>;
        <D.23597>:
        container = class->generic_container;
        goto <D.23599>;
        <D.23598>:
        if (gtd != 0B) goto <D.23600>; else goto <D.23601>;
        <D.23600>:
        container = gtd->generic_container;
        D.23602 = container == 0B;
        D.23603 = (long int) D.23602;
        D.23604 = __builtin_expect (D.23603, 0);
        if (D.23604 != 0) goto <D.23605>; else goto <D.23606>;
        <D.23605>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "class.c", 10125, "container");
        <D.23606>:
        <D.23601>:
        <D.23599>:
        mono_metadata_decode_table_row (image, 4, idx, &cols, 3);
        D.23607 = cols[2];
        D.23608 = mono_verifier_verify_field_signature (image, D.23607, 0B);
        if (D.23608 == 0) goto <D.23609>; else goto <D.23610>;
        <D.23609>:
        D.23611 = field->name;
        mono_error_set_type_load_class (error, class, "Could not verify field %s signature", D.23611);
        mono_class_set_failure (class, 7, 0B);
        return;
        <D.23610>:
        D.23607 = cols[2];
        sig.80 = mono_metadata_blob_heap (image, D.23607);
        sig = sig.80;
        sig.81 = sig;
        mono_metadata_decode_value (sig.81, &sig);
        sig.81 = sig;
        D.23614 = *sig.81;
        D.23615 = D.23614 != 6;
        D.23616 = (long int) D.23615;
        D.23617 = __builtin_expect (D.23616, 0);
        if (D.23617 != 0) goto <D.23618>; else goto <D.23619>;
        <D.23618>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "class.c", 10141, "*sig == 0x06");
        <D.23619>:
        sig.81 = sig;
        D.23620 = sig.81 + 1;
        D.23621 = cols[0];
        D.23622 = (short int) D.23621;
        D.23623 = (int) D.23622;
        D.23624 = mono_metadata_parse_type_full (image, container, 5, D.23623, D.23620, &sig);
        field->type = D.23624;
        D.23625 = field->type;
        if (D.23625 == 0B) goto <D.23626>; else goto <D.23627>;
        <D.23626>:
        D.23611 = field->name;
        D.23628 = monoeg_g_strdup_printf ("Could not load field %s type", D.23611);
        mono_class_set_failure_from_loader_error (class, error, D.23628);
        <D.23627>:
      }
    finally
      {
        sig = {CLOBBER};
        cols = {CLOBBER};
      }
  }
  <D.23585>:
}


mono_class_inflate_generic_type_no_copy (struct MonoImage * image, struct MonoType * type, struct MonoGenericContext * context, struct MonoError * error)
{
  int D.23634;
  struct MonoType * D.23637;
  long unsigned int D.23640;
  long unsigned int D.23641;
  struct MonoType * inflated;

  inflated = 0B;
  mono_error_init (error);
  if (context != 0B) goto <D.23632>; else goto <D.23633>;
  <D.23632>:
  inflated = inflate_generic_type (image, type, context, error);
  D.23634 = mono_error_ok (error);
  if (D.23634 == 0) goto <D.23635>; else goto <D.23636>;
  <D.23635>:
  D.23637 = 0B;
  return D.23637;
  <D.23636>:
  <D.23633>:
  if (inflated == 0B) goto <D.23638>; else goto <D.23639>;
  <D.23638>:
  D.23637 = type;
  return D.23637;
  <D.23639>:
  D.23640 = mono_stats.inflated_type_count;
  D.23641 = D.23640 + 1;
  mono_stats.inflated_type_count = D.23641;
  D.23637 = inflated;
  return D.23637;
}


mono_type_has_exceptions (struct MonoType * type)
{
  unsigned char D.23643;
  int D.23644;
  gboolean D.23645;
  struct MonoClass * D.23646;
  unsigned char D.23647;
  struct MonoArrayType * D.23648;
  struct MonoClass * D.23649;
  unsigned char D.23650;
  struct MonoGenericClass * D.23651;
  struct MonoClass * D.23652;
  unsigned char D.23653;

  D.23643 = type->type;
  D.23644 = (int) D.23643;
  switch (D.23644) <default: <D.23654>, case 17: <D.18769>, case 18: <D.18768>, case 20: <D.18771>, case 21: <D.18772>, case 29: <D.18770>>
  <D.18768>:
  <D.18769>:
  <D.18770>:
  D.23646 = type->data.klass;
  D.23647 = D.23646->exception_type;
  D.23645 = (gboolean) D.23647;
  return D.23645;
  <D.18771>:
  D.23648 = type->data.array;
  D.23649 = D.23648->eklass;
  D.23650 = D.23649->exception_type;
  D.23645 = (gboolean) D.23650;
  return D.23645;
  <D.18772>:
  D.23651 = type->data.generic_class;
  D.23652 = mono_generic_class_get_class (D.23651);
  D.23653 = D.23652->exception_type;
  D.23645 = (gboolean) D.23653;
  return D.23645;
  <D.23654>:
  D.23645 = 0;
  return D.23645;
}


mono_memory_barrier ()
{
  __sync_synchronize ();
}


mono_type_get_basic_type_from_generic (struct MonoType * type)
{
  unsigned char D.23656;
  unsigned char D.23657;
  unsigned char D.23660;
  _Bool D.23661;
  _Bool D.23662;
  _Bool D.23663;
  struct MonoType * D.23666;
  struct MonoClass * D.23667;

  D.23656 = BIT_FIELD_REF <*type, 8, 56>;
  D.23657 = D.23656 & 64;
  if (D.23657 == 0) goto <D.23658>; else goto <D.23659>;
  <D.23658>:
  D.23660 = type->type;
  D.23661 = D.23660 == 19;
  D.23662 = D.23660 == 30;
  D.23663 = D.23661 | D.23662;
  if (D.23663 != 0) goto <D.23664>; else goto <D.23665>;
  <D.23664>:
  D.23667 = mono_defaults.object_class;
  D.23666 = &D.23667->byval_arg;
  return D.23666;
  <D.23665>:
  <D.23659>:
  D.23666 = type;
  return D.23666;
}


mono_class_layout_fields (struct MonoClass * class)
{
  unsigned int D.23669;
  unsigned int D.23670;
  unsigned char D.23673;
  unsigned char D.23674;
  struct MonoClassField * D.23677;
  unsigned int i.82;
  unsigned int D.23679;
  struct MonoType * D.23680;
  short unsigned int D.23681;
  int D.23682;
  int D.23683;
  int D.23689;
  int D.23691;
  unsigned char D.23693;
  struct MonoImage * D.23695;
  struct MonoImage * D.23696;
  int D.23697;
  struct MonoClass * D.23699;
  int D.23700;
  int D.23706;
  int D.23708;
  unsigned char D.23710;
  int D.23712;
  struct MonoClass * D.23714;
  int D.23715;
  int D.23719;
  int D.23721;
  unsigned char D.23723;
  int D.23725;
  struct MonoClass * D.23727;
  int D.23728;
  struct MonoClass * D.23737;
  unsigned char D.23740;
  int D.23743;
  int D.23745;
  int D.18876;
  int iftmp.83;
  int D.18875;
  const char[9] * D.23751;
  unsigned char D.23752;
  int D.23753;
  unsigned char D.23754;
  int D.23755;
  _Bool D.23756;
  _Bool D.23757;
  _Bool D.23758;
  const unsigned char * D.23761;
  unsigned char D.23762;
  int D.23763;
  const unsigned char * D.23764;
  unsigned char D.23765;
  int D.23766;
  _Bool D.23767;
  _Bool D.23768;
  const unsigned char * D.23771;
  unsigned char D.23772;
  int D.23773;
  const unsigned char * D.23774;
  unsigned char D.23775;
  int D.23776;
  _Bool D.23777;
  _Bool D.23778;
  const unsigned char * D.23781;
  unsigned char D.23782;
  int D.23783;
  const unsigned char * D.23784;
  unsigned char D.23785;
  int D.23786;
  const char * D.23788;
  int D.23799;
  int D.23801;
  unsigned char D.23803;
  int D.23805;
  struct MonoClass * D.23807;
  int D.23808;
  int D.23815;
  int D.18886;
  int iftmp.84;
  int D.18885;
  const char[10] * D.23821;
  unsigned char D.23822;
  int D.23823;
  unsigned char D.23824;
  int D.23825;
  _Bool D.23826;
  _Bool D.23827;
  _Bool D.23828;
  const unsigned char * D.23831;
  unsigned char D.23832;
  int D.23833;
  const unsigned char * D.23834;
  unsigned char D.23835;
  int D.23836;
  _Bool D.23837;
  _Bool D.23838;
  const unsigned char * D.23841;
  unsigned char D.23842;
  int D.23843;
  const unsigned char * D.23844;
  unsigned char D.23845;
  int D.23846;
  _Bool D.23847;
  _Bool D.23848;
  const unsigned char * D.23851;
  unsigned char D.23852;
  int D.23853;
  const unsigned char * D.23854;
  unsigned char D.23855;
  int D.23856;
  const char * D.23858;
  int D.23861;
  int iftmp.85;
  unsigned char D.23863;
  unsigned char D.23864;
  <unnamed-unsigned:4> D.23867;
  int D.23868;
  int align.86;
  int D.23874;
  int D.23876;
  int D.23879;
  struct MonoClass * D.23881;
  int D.23882;
  unsigned int align.87;
  unsigned int D.23884;
  int align.88;
  unsigned char D.23886;
  int D.23887;
  int D.23888;
  unsigned char D.23889;
  int real_size.89;
  int D.23893;
  int D.23894;
  int D.23895;
  int D.23896;
  int D.23897;
  int iftmp.90;
  unsigned char D.23901;
  unsigned char D.23902;
  _Bool D.23905;
  long int D.23906;
  long int D.23907;
  unsigned int D.23910;
  unsigned int D.23911;
  unsigned int D.23912;
  int D.23913;
  int D.23914;
  int D.23915;
  int D.23918;
  int D.23919;
  int D.23920;
  int D.18906;
  int iftmp.91;
  int D.18905;
  unsigned char D.23926;
  int D.23927;
  _Bool D.23928;
  _Bool D.23929;
  _Bool D.23930;
  const unsigned char * D.23933;
  unsigned char D.23934;
  int D.23935;
  _Bool D.23936;
  _Bool D.23937;
  const unsigned char * D.23940;
  unsigned char D.23941;
  int D.23942;
  _Bool D.23943;
  _Bool D.23944;
  const unsigned char * D.23947;
  unsigned char D.23948;
  int D.23949;
  const char * D.23951;
  int D.23956;
  int iftmp.92;
  int align.93;
  int D.23962;
  unsigned char D.23963;
  unsigned int D.23964;
  unsigned int D.23965;
  int D.23966;
  int D.23969;
  int D.23971;
  struct MonoClass * D.23973;
  int D.23974;
  unsigned int D.23975;
  unsigned int D.23978;
  unsigned int D.23984;
  unsigned int D.23987;
  unsigned int D.23988;
  unsigned int D.23989;
  unsigned char D.23990;
  unsigned int D.23991;
  unsigned int D.23992;
  int D.18922;
  int iftmp.94;
  int D.18921;
  unsigned char D.24000;
  int D.24001;
  _Bool D.24002;
  _Bool D.24003;
  _Bool D.24004;
  const unsigned char * D.24007;
  unsigned char D.24008;
  int D.24009;
  _Bool D.24010;
  _Bool D.24011;
  const unsigned char * D.24014;
  unsigned char D.24015;
  int D.24016;
  _Bool D.24017;
  _Bool D.24018;
  const unsigned char * D.24021;
  unsigned char D.24022;
  int D.24023;
  const char * D.24025;
  int D.24028;
  int D.24031;
  int D.24032;
  int align.95;
  int D.24034;
  int D.24035;
  int D.24036;
  int D.24037;
  unsigned int D.24038;
  int D.24039;
  int i;
  const int top;
  guint32 layout;
  guint32 pass;
  guint32 passes;
  guint32 real_size;
  gboolean gc_aware_layout;
  struct MonoClassField * field;

  D.23669 = class->field.count;
  top = (const int) D.23669;
  D.23670 = class->flags;
  layout = D.23670 & 24;
  gc_aware_layout = 0;
  if (layout == 0) goto <D.23671>; else goto <D.23672>;
  <D.23671>:
  D.23673 = BIT_FIELD_REF <*class, 8, 160>;
  D.23674 = D.23673 & 8;
  if (D.23674 == 0) goto <D.23675>; else goto <D.23676>;
  <D.23675>:
  gc_aware_layout = 1;
  <D.23676>:
  <D.23672>:
  i = 0;
  goto <D.18853>;
  <D.18852>:
  {
    struct MonoType * ftype;

    D.23677 = class->fields;
    i.82 = (unsigned int) i;
    D.23679 = i.82 * 16;
    field = D.23677 + D.23679;
    D.23680 = field->type;
    D.23681 = D.23680->attrs;
    D.23682 = (int) D.23681;
    D.23683 = D.23682 & 16;
    if (D.23683 == 0) goto <D.23684>; else goto <D.23685>;
    <D.23684>:
    D.23680 = field->type;
    ftype = mono_type_get_underlying_type (D.23680);
    ftype = mono_type_get_basic_type_from_generic (ftype);
    D.23689 = mono_type_is_reference (ftype);
    if (D.23689 != 0) goto <D.23686>; else goto <D.23690>;
    <D.23690>:
    D.23691 = mono_gc_is_moving ();
    if (D.23691 == 0) goto <D.23692>; else goto <D.23687>;
    <D.23692>:
    D.23693 = ftype->type;
    if (D.23693 == 25) goto <D.23694>; else goto <D.23687>;
    <D.23694>:
    D.23695 = class->image;
    D.23696 = mono_defaults.corlib;
    if (D.23695 == D.23696) goto <D.23686>; else goto <D.23687>;
    <D.23687>:
    D.23697 = mono_type_is_struct (ftype);
    if (D.23697 != 0) goto <D.23698>; else goto <D.23688>;
    <D.23698>:
    D.23699 = mono_class_from_mono_type (ftype);
    D.23700 = mono_class_has_references (D.23699);
    if (D.23700 != 0) goto <D.23686>; else goto <D.23688>;
    <D.23686>:
    class->has_references = 1;
    <D.23688>:
    <D.23685>:
  }
  i = i + 1;
  <D.18853>:
  if (i < top) goto <D.18852>; else goto <D.18854>;
  <D.18854>:
  i = 0;
  goto <D.18857>;
  <D.18856>:
  {
    struct MonoType * ftype;

    D.23677 = class->fields;
    i.82 = (unsigned int) i;
    D.23679 = i.82 * 16;
    field = D.23677 + D.23679;
    D.23680 = field->type;
    D.23681 = D.23680->attrs;
    D.23682 = (int) D.23681;
    D.23683 = D.23682 & 16;
    if (D.23683 != 0) goto <D.23701>; else goto <D.23702>;
    <D.23701>:
    D.23680 = field->type;
    ftype = mono_type_get_underlying_type (D.23680);
    ftype = mono_type_get_basic_type_from_generic (ftype);
    D.23706 = mono_type_is_reference (ftype);
    if (D.23706 != 0) goto <D.23703>; else goto <D.23707>;
    <D.23707>:
    D.23708 = mono_gc_is_moving ();
    if (D.23708 == 0) goto <D.23709>; else goto <D.23704>;
    <D.23709>:
    D.23710 = ftype->type;
    if (D.23710 == 25) goto <D.23711>; else goto <D.23704>;
    <D.23711>:
    D.23695 = class->image;
    D.23696 = mono_defaults.corlib;
    if (D.23695 == D.23696) goto <D.23703>; else goto <D.23704>;
    <D.23704>:
    D.23712 = mono_type_is_struct (ftype);
    if (D.23712 != 0) goto <D.23713>; else goto <D.23705>;
    <D.23713>:
    D.23714 = mono_class_from_mono_type (ftype);
    D.23715 = mono_class_has_references (D.23714);
    if (D.23715 != 0) goto <D.23703>; else goto <D.23705>;
    <D.23703>:
    class->has_static_refs = 1;
    <D.23705>:
    <D.23702>:
  }
  i = i + 1;
  <D.18857>:
  if (i < top) goto <D.18856>; else goto <D.18858>;
  <D.18858>:
  i = 0;
  goto <D.18861>;
  <D.18860>:
  {
    struct MonoType * ftype;

    D.23677 = class->fields;
    i.82 = (unsigned int) i;
    D.23679 = i.82 * 16;
    field = D.23677 + D.23679;
    D.23680 = field->type;
    ftype = mono_type_get_underlying_type (D.23680);
    ftype = mono_type_get_basic_type_from_generic (ftype);
    D.23719 = mono_type_is_reference (ftype);
    if (D.23719 != 0) goto <D.23716>; else goto <D.23720>;
    <D.23720>:
    D.23721 = mono_gc_is_moving ();
    if (D.23721 == 0) goto <D.23722>; else goto <D.23717>;
    <D.23722>:
    D.23723 = ftype->type;
    if (D.23723 == 25) goto <D.23724>; else goto <D.23717>;
    <D.23724>:
    D.23695 = class->image;
    D.23696 = mono_defaults.corlib;
    if (D.23695 == D.23696) goto <D.23716>; else goto <D.23717>;
    <D.23717>:
    D.23725 = mono_type_is_struct (ftype);
    if (D.23725 != 0) goto <D.23726>; else goto <D.23718>;
    <D.23726>:
    D.23727 = mono_class_from_mono_type (ftype);
    D.23728 = mono_class_has_references (D.23727);
    if (D.23728 != 0) goto <D.23716>; else goto <D.23718>;
    <D.23716>:
    D.23680 = field->type;
    D.23681 = D.23680->attrs;
    D.23682 = (int) D.23681;
    D.23683 = D.23682 & 16;
    if (D.23683 != 0) goto <D.23729>; else goto <D.23730>;
    <D.23729>:
    class->has_static_refs = 1;
    goto <D.23731>;
    <D.23730>:
    class->has_references = 1;
    <D.23731>:
    <D.23718>:
  }
  i = i + 1;
  <D.18861>:
  if (i < top) goto <D.18860>; else goto <D.18862>;
  <D.18862>:
  switch (layout) <default: <D.23981>, case 0: <D.18863>, case 8: <D.18864>, case 16: <D.18894>>
  <D.18863>:
  <D.18864>:
  if (gc_aware_layout != 0) goto <D.23732>; else goto <D.23733>;
  <D.23732>:
  passes = 2;
  goto <D.23734>;
  <D.23733>:
  passes = 1;
  <D.23734>:
  if (layout != 0) goto <D.23735>; else goto <D.23736>;
  <D.23735>:
  passes = 1;
  <D.23736>:
  D.23737 = class->parent;
  if (D.23737 != 0B) goto <D.23738>; else goto <D.23739>;
  <D.23738>:
  D.23737 = class->parent;
  mono_class_setup_fields (D.23737);
  D.23737 = class->parent;
  D.23740 = D.23737->exception_type;
  if (D.23740 != 0) goto <D.23741>; else goto <D.23742>;
  <D.23741>:
  mono_class_set_failure (class, 7, 0B);
  return;
  <D.23742>:
  D.23737 = class->parent;
  D.23743 = D.23737->instance_size;
  real_size = (guint32) D.23743;
  goto <D.23744>;
  <D.23739>:
  real_size = 8;
  <D.23744>:
  pass = 0;
  goto <D.18891>;
  <D.18890>:
  i = 0;
  goto <D.18888>;
  <D.18887>:
  {
    gint32 align;
    guint32 size;
    struct MonoType * ftype;

    try
      {
        D.23677 = class->fields;
        i.82 = (unsigned int) i;
        D.23679 = i.82 * 16;
        field = D.23677 + D.23679;
        D.23680 = field->type;
        D.23681 = D.23680->attrs;
        D.23682 = (int) D.23681;
        D.23745 = D.23682 & 1536;
        if (D.23745 != 0) goto <D.23746>; else goto <D.23747>;
        <D.23746>:
        {
          size_t __s1_len;
          size_t __s2_len;

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

            __s2 = mono_field_get_name (field);
            D.23751 = "_Deleted";
            D.23752 = MEM[(const unsigned char *)D.23751];
            D.23753 = (int) D.23752;
            D.23754 = *__s2;
            D.23755 = (int) D.23754;
            __result = D.23753 - D.23755;
            {
              D.23756 = __s2_len != 0;
              D.23757 = __result == 0;
              D.23758 = D.23756 & D.23757;
              if (D.23758 != 0) goto <D.23759>; else goto <D.23760>;
              <D.23759>:
              D.23761 = &MEM[(void *)"_Deleted" + 1B];
              D.23762 = *D.23761;
              D.23763 = (int) D.23762;
              D.23764 = __s2 + 1;
              D.23765 = *D.23764;
              D.23766 = (int) D.23765;
              __result = D.23763 - D.23766;
              D.23767 = __s2_len > 1;
              D.23757 = __result == 0;
              D.23768 = D.23767 & D.23757;
              if (D.23768 != 0) goto <D.23769>; else goto <D.23770>;
              <D.23769>:
              D.23771 = &MEM[(void *)"_Deleted" + 2B];
              D.23772 = *D.23771;
              D.23773 = (int) D.23772;
              D.23774 = __s2 + 2;
              D.23775 = *D.23774;
              D.23776 = (int) D.23775;
              __result = D.23773 - D.23776;
              D.23777 = __s2_len > 2;
              D.23757 = __result == 0;
              D.23778 = D.23777 & D.23757;
              if (D.23778 != 0) goto <D.23779>; else goto <D.23780>;
              <D.23779>:
              D.23781 = &MEM[(void *)"_Deleted" + 3B];
              D.23782 = *D.23781;
              D.23783 = (int) D.23782;
              D.23784 = __s2 + 3;
              D.23785 = *D.23784;
              D.23786 = (int) D.23785;
              __result = D.23783 - D.23786;
              <D.23780>:
              <D.23770>:
              <D.23760>:
            }
            D.18875 = __result;
          }
          iftmp.83 = -D.18875;
          goto <D.23787>;
          <D.23750>:
          D.23788 = mono_field_get_name (field);
          iftmp.83 = __builtin_strcmp (D.23788, "_Deleted");
          <D.23787>:
          D.18876 = iftmp.83;
        }
        if (D.18876 == 0) goto <D.23789>; else goto <D.23790>;
        <D.23789>:
        // predicted unlikely by continue predictor.
        goto <D.18877>;
        <D.23790>:
        <D.23747>:
        D.23680 = field->type;
        D.23681 = D.23680->attrs;
        D.23682 = (int) D.23681;
        D.23683 = D.23682 & 16;
        if (D.23683 != 0) goto <D.23791>; else goto <D.23792>;
        <D.23791>:
        // predicted unlikely by continue predictor.
        goto <D.18877>;
        <D.23792>:
        D.23680 = field->type;
        ftype = mono_type_get_underlying_type (D.23680);
        ftype = mono_type_get_basic_type_from_generic (ftype);
        if (gc_aware_layout != 0) goto <D.23793>; else goto <D.23794>;
        <D.23793>:
        D.23799 = mono_type_is_reference (ftype);
        if (D.23799 != 0) goto <D.23795>; else goto <D.23800>;
        <D.23800>:
        D.23801 = mono_gc_is_moving ();
        if (D.23801 == 0) goto <D.23802>; else goto <D.23796>;
        <D.23802>:
        D.23803 = ftype->type;
        if (D.23803 == 25) goto <D.23804>; else goto <D.23796>;
        <D.23804>:
        D.23695 = class->image;
        D.23696 = mono_defaults.corlib;
        if (D.23695 == D.23696) goto <D.23795>; else goto <D.23796>;
        <D.23796>:
        D.23805 = mono_type_is_struct (ftype);
        if (D.23805 != 0) goto <D.23806>; else goto <D.23797>;
        <D.23806>:
        D.23807 = mono_class_from_mono_type (ftype);
        D.23808 = mono_class_has_references (D.23807);
        if (D.23808 != 0) goto <D.23795>; else goto <D.23797>;
        <D.23795>:
        if (pass == 1) goto <D.23809>; else goto <D.23810>;
        <D.23809>:
        // predicted unlikely by continue predictor.
        goto <D.18877>;
        <D.23810>:
        goto <D.23798>;
        <D.23797>:
        if (pass == 0) goto <D.23811>; else goto <D.23812>;
        <D.23811>:
        // predicted unlikely by continue predictor.
        goto <D.18877>;
        <D.23812>:
        <D.23798>:
        <D.23794>:
        if (top == 1) goto <D.23813>; else goto <D.23814>;
        <D.23813>:
        D.23815 = class->instance_size;
        if (D.23815 == 8) goto <D.23816>; else goto <D.23817>;
        <D.23816>:
        {
          size_t __s1_len;
          size_t __s2_len;

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

            __s2 = mono_field_get_name (field);
            D.23821 = "$PRIVATE$";
            D.23822 = MEM[(const unsigned char *)D.23821];
            D.23823 = (int) D.23822;
            D.23824 = *__s2;
            D.23825 = (int) D.23824;
            __result = D.23823 - D.23825;
            {
              D.23826 = __s2_len != 0;
              D.23827 = __result == 0;
              D.23828 = D.23826 & D.23827;
              if (D.23828 != 0) goto <D.23829>; else goto <D.23830>;
              <D.23829>:
              D.23831 = &MEM[(void *)"$PRIVATE$" + 1B];
              D.23832 = *D.23831;
              D.23833 = (int) D.23832;
              D.23834 = __s2 + 1;
              D.23835 = *D.23834;
              D.23836 = (int) D.23835;
              __result = D.23833 - D.23836;
              D.23837 = __s2_len > 1;
              D.23827 = __result == 0;
              D.23838 = D.23837 & D.23827;
              if (D.23838 != 0) goto <D.23839>; else goto <D.23840>;
              <D.23839>:
              D.23841 = &MEM[(void *)"$PRIVATE$" + 2B];
              D.23842 = *D.23841;
              D.23843 = (int) D.23842;
              D.23844 = __s2 + 2;
              D.23845 = *D.23844;
              D.23846 = (int) D.23845;
              __result = D.23843 - D.23846;
              D.23847 = __s2_len > 2;
              D.23827 = __result == 0;
              D.23848 = D.23847 & D.23827;
              if (D.23848 != 0) goto <D.23849>; else goto <D.23850>;
              <D.23849>:
              D.23851 = &MEM[(void *)"$PRIVATE$" + 3B];
              D.23852 = *D.23851;
              D.23853 = (int) D.23852;
              D.23854 = __s2 + 3;
              D.23855 = *D.23854;
              D.23856 = (int) D.23855;
              __result = D.23853 - D.23856;
              <D.23850>:
              <D.23840>:
              <D.23830>:
            }
            D.18885 = __result;
          }
          iftmp.84 = -D.18885;
          goto <D.23857>;
          <D.23820>:
          D.23858 = mono_field_get_name (field);
          iftmp.84 = __builtin_strcmp (D.23858, "$PRIVATE$");
          <D.23857>:
          D.18886 = iftmp.84;
        }
        if (D.18886 == 0) goto <D.23859>; else goto <D.23860>;
        <D.23859>:
        // predicted unlikely by continue predictor.
        goto <D.18877>;
        <D.23860>:
        <D.23817>:
        <D.23814>:
        D.23680 = field->type;
        D.23861 = mono_type_size (D.23680, &align);
        size = (guint32) D.23861;
        D.23863 = BIT_FIELD_REF <*class, 8, 176>;
        D.23864 = D.23863 & 15;
        if (D.23864 != 0) goto <D.23865>; else goto <D.23866>;
        <D.23865>:
        D.23867 = class->packing_size;
        D.23868 = (int) D.23867;
        align.86 = align;
        iftmp.85 = MIN_EXPR <D.23868, align.86>;
        goto <D.23870>;
        <D.23866>:
        iftmp.85 = align;
        <D.23870>:
        align = iftmp.85;
        D.23874 = mono_type_is_reference (ftype);
        if (D.23874 != 0) goto <D.23871>; else goto <D.23875>;
        <D.23875>:
        D.23876 = mono_gc_is_moving ();
        if (D.23876 == 0) goto <D.23877>; else goto <D.23872>;
        <D.23877>:
        D.23803 = ftype->type;
        if (D.23803 == 25) goto <D.23878>; else goto <D.23872>;
        <D.23878>:
        D.23695 = class->image;
        D.23696 = mono_defaults.corlib;
        if (D.23695 == D.23696) goto <D.23871>; else goto <D.23872>;
        <D.23872>:
        D.23879 = mono_type_is_struct (ftype);
        if (D.23879 != 0) goto <D.23880>; else goto <D.23873>;
        <D.23880>:
        D.23881 = mono_class_from_mono_type (ftype);
        D.23882 = mono_class_has_references (D.23881);
        if (D.23882 != 0) goto <D.23871>; else goto <D.23873>;
        <D.23871>:
        align.86 = align;
        align.87 = (unsigned int) align.86;
        D.23884 = MAX_EXPR <align.87, 4>;
        align.88 = (int) D.23884;
        align = align.88;
        <D.23873>:
        D.23886 = class->min_align;
        D.23887 = (int) D.23886;
        align.86 = align;
        D.23888 = MAX_EXPR <D.23887, align.86>;
        D.23889 = (unsigned char) D.23888;
        class->min_align = D.23889;
        real_size.89 = (int) real_size;
        field->offset = real_size.89;
        align.86 = align;
        if (align.86 != 0) goto <D.23891>; else goto <D.23892>;
        <D.23891>:
        D.23893 = field->offset;
        align.86 = align;
        D.23894 = align.86 + -1;
        D.23895 = D.23893 + D.23894;
        field->offset = D.23895;
        D.23893 = field->offset;
        align.86 = align;
        D.23896 = -align.86;
        D.23897 = D.23893 & D.23896;
        field->offset = D.23897;
        <D.23892>:
        D.23695 = class->image;
        D.23901 = BIT_FIELD_REF <*D.23695, 8, 128>;
        D.23902 = D.23901 & 8;
        if (D.23902 == 0) goto <D.23903>; else goto <D.23899>;
        <D.23903>:
        D.23893 = field->offset;
        if (D.23893 <= 0) goto <D.23904>; else goto <D.23899>;
        <D.23904>:
        iftmp.90 = 1;
        goto <D.23900>;
        <D.23899>:
        iftmp.90 = 0;
        <D.23900>:
        D.23905 = iftmp.90 != 0;
        D.23906 = (long int) D.23905;
        D.23907 = __builtin_expect (D.23906, 0);
        if (D.23907 != 0) goto <D.23908>; else goto <D.23909>;
        <D.23908>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "class.c", 1894, "class->image->dynamic || field->offset > 0");
        <D.23909>:
        D.23893 = field->offset;
        D.23910 = (unsigned int) D.23893;
        real_size = D.23910 + size;
      }
    finally
      {
        align = {CLOBBER};
      }
  }
  <D.18877>:
  i = i + 1;
  <D.18888>:
  if (i < top) goto <D.18887>; else goto <D.18889>;
  <D.18889>:
  D.23815 = class->instance_size;
  D.23911 = (unsigned int) D.23815;
  D.23912 = MAX_EXPR <D.23911, real_size>;
  D.23913 = (int) D.23912;
  class->instance_size = D.23913;
  D.23815 = class->instance_size;
  D.23886 = class->min_align;
  D.23887 = (int) D.23886;
  D.23914 = D.23887 + -1;
  D.23915 = D.23815 & D.23914;
  if (D.23915 != 0) goto <D.23916>; else goto <D.23917>;
  <D.23916>:
  D.23815 = class->instance_size;
  D.23886 = class->min_align;
  D.23887 = (int) D.23886;
  D.23914 = D.23887 + -1;
  D.23918 = D.23815 + D.23914;
  class->instance_size = D.23918;
  D.23815 = class->instance_size;
  D.23886 = class->min_align;
  D.23887 = (int) D.23886;
  D.23919 = -D.23887;
  D.23920 = D.23815 & D.23919;
  class->instance_size = D.23920;
  <D.23917>:
  pass = pass + 1;
  <D.18891>:
  if (pass < passes) goto <D.18890>; else goto <D.18892>;
  <D.18892>:
  goto <D.18893>;
  <D.18894>:
  real_size = 0;
  i = 0;
  goto <D.18909>;
  <D.18908>:
  {
    gint32 align;
    guint32 size;
    struct MonoType * ftype;

    try
      {
        D.23677 = class->fields;
        i.82 = (unsigned int) i;
        D.23679 = i.82 * 16;
        field = D.23677 + D.23679;
        D.23680 = field->type;
        D.23681 = D.23680->attrs;
        D.23682 = (int) D.23681;
        D.23745 = D.23682 & 1536;
        if (D.23745 != 0) goto <D.23921>; else goto <D.23922>;
        <D.23921>:
        {
          size_t __s1_len;
          size_t __s2_len;

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

            __s2 = mono_field_get_name (field);
            D.23751 = "_Deleted";
            D.23752 = MEM[(const unsigned char *)D.23751];
            D.23753 = (int) D.23752;
            D.23926 = *__s2;
            D.23927 = (int) D.23926;
            __result = D.23753 - D.23927;
            {
              D.23928 = __s2_len != 0;
              D.23929 = __result == 0;
              D.23930 = D.23928 & D.23929;
              if (D.23930 != 0) goto <D.23931>; else goto <D.23932>;
              <D.23931>:
              D.23761 = &MEM[(void *)"_Deleted" + 1B];
              D.23762 = *D.23761;
              D.23763 = (int) D.23762;
              D.23933 = __s2 + 1;
              D.23934 = *D.23933;
              D.23935 = (int) D.23934;
              __result = D.23763 - D.23935;
              D.23936 = __s2_len > 1;
              D.23929 = __result == 0;
              D.23937 = D.23936 & D.23929;
              if (D.23937 != 0) goto <D.23938>; else goto <D.23939>;
              <D.23938>:
              D.23771 = &MEM[(void *)"_Deleted" + 2B];
              D.23772 = *D.23771;
              D.23773 = (int) D.23772;
              D.23940 = __s2 + 2;
              D.23941 = *D.23940;
              D.23942 = (int) D.23941;
              __result = D.23773 - D.23942;
              D.23943 = __s2_len > 2;
              D.23929 = __result == 0;
              D.23944 = D.23943 & D.23929;
              if (D.23944 != 0) goto <D.23945>; else goto <D.23946>;
              <D.23945>:
              D.23781 = &MEM[(void *)"_Deleted" + 3B];
              D.23782 = *D.23781;
              D.23783 = (int) D.23782;
              D.23947 = __s2 + 3;
              D.23948 = *D.23947;
              D.23949 = (int) D.23948;
              __result = D.23783 - D.23949;
              <D.23946>:
              <D.23939>:
              <D.23932>:
            }
            D.18905 = __result;
          }
          iftmp.91 = -D.18905;
          goto <D.23950>;
          <D.23925>:
          D.23951 = mono_field_get_name (field);
          iftmp.91 = __builtin_strcmp (D.23951, "_Deleted");
          <D.23950>:
          D.18906 = iftmp.91;
        }
        if (D.18906 == 0) goto <D.23952>; else goto <D.23953>;
        <D.23952>:
        // predicted unlikely by continue predictor.
        goto <D.18907>;
        <D.23953>:
        <D.23922>:
        D.23680 = field->type;
        D.23681 = D.23680->attrs;
        D.23682 = (int) D.23681;
        D.23683 = D.23682 & 16;
        if (D.23683 != 0) goto <D.23954>; else goto <D.23955>;
        <D.23954>:
        // predicted unlikely by continue predictor.
        goto <D.18907>;
        <D.23955>:
        D.23680 = field->type;
        D.23956 = mono_type_size (D.23680, &align);
        size = (guint32) D.23956;
        D.23863 = BIT_FIELD_REF <*class, 8, 176>;
        D.23864 = D.23863 & 15;
        if (D.23864 != 0) goto <D.23958>; else goto <D.23959>;
        <D.23958>:
        D.23867 = class->packing_size;
        D.23868 = (int) D.23867;
        align.93 = align;
        iftmp.92 = MIN_EXPR <D.23868, align.93>;
        goto <D.23961>;
        <D.23959>:
        iftmp.92 = align;
        <D.23961>:
        align = iftmp.92;
        D.23886 = class->min_align;
        D.23887 = (int) D.23886;
        align.93 = align;
        D.23962 = MAX_EXPR <D.23887, align.93>;
        D.23963 = (unsigned char) D.23962;
        class->min_align = D.23963;
        D.23893 = field->offset;
        D.23964 = (unsigned int) D.23893;
        D.23965 = D.23964 + 8;
        D.23966 = (int) D.23965;
        field->offset = D.23966;
        D.23680 = field->type;
        ftype = mono_type_get_underlying_type (D.23680);
        ftype = mono_type_get_basic_type_from_generic (ftype);
        D.23969 = mono_type_is_reference (ftype);
        if (D.23969 != 0) goto <D.23967>; else goto <D.23970>;
        <D.23970>:
        D.23971 = mono_type_is_struct (ftype);
        if (D.23971 != 0) goto <D.23972>; else goto <D.23968>;
        <D.23972>:
        D.23973 = mono_class_from_mono_type (ftype);
        D.23974 = mono_class_has_references (D.23973);
        if (D.23974 != 0) goto <D.23967>; else goto <D.23968>;
        <D.23967>:
        D.23893 = field->offset;
        D.23964 = (unsigned int) D.23893;
        D.23975 = D.23964 & 3;
        if (D.23975 != 0) goto <D.23976>; else goto <D.23977>;
        <D.23976>:
        mono_class_set_failure (class, 7, 0B);
        <D.23977>:
        <D.23968>:
        D.23893 = field->offset;
        D.23910 = (unsigned int) D.23893;
        D.23978 = D.23910 + size;
        real_size = MAX_EXPR <D.23978, real_size>;
      }
    finally
      {
        align = {CLOBBER};
      }
  }
  <D.18907>:
  i = i + 1;
  <D.18909>:
  if (i < top) goto <D.18908>; else goto <D.18910>;
  <D.18910>:
  D.23815 = class->instance_size;
  D.23911 = (unsigned int) D.23815;
  D.23912 = MAX_EXPR <D.23911, real_size>;
  D.23913 = (int) D.23912;
  class->instance_size = D.23913;
  D.23815 = class->instance_size;
  D.23886 = class->min_align;
  D.23887 = (int) D.23886;
  D.23914 = D.23887 + -1;
  D.23915 = D.23815 & D.23914;
  if (D.23915 != 0) goto <D.23979>; else goto <D.23980>;
  <D.23979>:
  D.23815 = class->instance_size;
  D.23886 = class->min_align;
  D.23887 = (int) D.23886;
  D.23914 = D.23887 + -1;
  D.23918 = D.23815 + D.23914;
  class->instance_size = D.23918;
  D.23815 = class->instance_size;
  D.23886 = class->min_align;
  D.23887 = (int) D.23886;
  D.23919 = -D.23887;
  D.23920 = D.23815 & D.23919;
  class->instance_size = D.23920;
  <D.23980>:
  goto <D.18893>;
  <D.23981>:
  <D.18893>:
  if (layout != 16) goto <D.23982>; else goto <D.23983>;
  <D.23982>:
  D.23815 = class->instance_size;
  D.23984 = (unsigned int) D.23815;
  if (D.23984 <= 12) goto <D.23985>; else goto <D.23986>;
  <D.23985>:
  D.23815 = class->instance_size;
  D.23984 = (unsigned int) D.23815;
  D.23987 = D.23984 + 4294967288;
  D.23886 = class->min_align;
  D.23988 = (unsigned int) D.23886;
  D.23989 = MAX_EXPR <D.23987, D.23988>;
  D.23990 = (unsigned char) D.23989;
  class->min_align = D.23990;
  <D.23986>:
  <D.23983>:
  mono_memory_barrier ();
  class->size_inited = 1;
  i = 0;
  goto <D.18925>;
  <D.18924>:
  {
    gint32 align;
    guint32 size;

    try
      {
        D.23677 = class->fields;
        i.82 = (unsigned int) i;
        D.23679 = i.82 * 16;
        field = D.23677 + D.23679;
        D.23680 = field->type;
        D.23681 = D.23680->attrs;
        D.23991 = (unsigned int) D.23681;
        D.23992 = D.23991 & 80;
        if (D.23992 != 16) goto <D.23993>; else goto <D.23994>;
        <D.23993>:
        // predicted unlikely by continue predictor.
        goto <D.18913>;
        <D.23994>:
        D.23680 = field->type;
        D.23681 = D.23680->attrs;
        D.23682 = (int) D.23681;
        D.23745 = D.23682 & 1536;
        if (D.23745 != 0) goto <D.23995>; else goto <D.23996>;
        <D.23995>:
        {
          size_t __s1_len;
          size_t __s2_len;

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

            __s2 = mono_field_get_name (field);
            D.23751 = "_Deleted";
            D.23752 = MEM[(const unsigned char *)D.23751];
            D.23753 = (int) D.23752;
            D.24000 = *__s2;
            D.24001 = (int) D.24000;
            __result = D.23753 - D.24001;
            {
              D.24002 = __s2_len != 0;
              D.24003 = __result == 0;
              D.24004 = D.24002 & D.24003;
              if (D.24004 != 0) goto <D.24005>; else goto <D.24006>;
              <D.24005>:
              D.23761 = &MEM[(void *)"_Deleted" + 1B];
              D.23762 = *D.23761;
              D.23763 = (int) D.23762;
              D.24007 = __s2 + 1;
              D.24008 = *D.24007;
              D.24009 = (int) D.24008;
              __result = D.23763 - D.24009;
              D.24010 = __s2_len > 1;
              D.24003 = __result == 0;
              D.24011 = D.24010 & D.24003;
              if (D.24011 != 0) goto <D.24012>; else goto <D.24013>;
              <D.24012>:
              D.23771 = &MEM[(void *)"_Deleted" + 2B];
              D.23772 = *D.23771;
              D.23773 = (int) D.23772;
              D.24014 = __s2 + 2;
              D.24015 = *D.24014;
              D.24016 = (int) D.24015;
              __result = D.23773 - D.24016;
              D.24017 = __s2_len > 2;
              D.24003 = __result == 0;
              D.24018 = D.24017 & D.24003;
              if (D.24018 != 0) goto <D.24019>; else goto <D.24020>;
              <D.24019>:
              D.23781 = &MEM[(void *)"_Deleted" + 3B];
              D.23782 = *D.23781;
              D.23783 = (int) D.23782;
              D.24021 = __s2 + 3;
              D.24022 = *D.24021;
              D.24023 = (int) D.24022;
              __result = D.23783 - D.24023;
              <D.24020>:
              <D.24013>:
              <D.24006>:
            }
            D.18921 = __result;
          }
          iftmp.94 = -D.18921;
          goto <D.24024>;
          <D.23999>:
          D.24025 = mono_field_get_name (field);
          iftmp.94 = __builtin_strcmp (D.24025, "_Deleted");
          <D.24024>:
          D.18922 = iftmp.94;
        }
        if (D.18922 == 0) goto <D.24026>; else goto <D.24027>;
        <D.24026>:
        // predicted unlikely by continue predictor.
        goto <D.18913>;
        <D.24027>:
        <D.23996>:
        D.23680 = field->type;
        D.24028 = mono_type_has_exceptions (D.23680);
        if (D.24028 != 0) goto <D.24029>; else goto <D.24030>;
        <D.24029>:
        mono_class_set_failure (class, 7, 0B);
        goto <D.18923>;
        <D.24030>:
        D.23680 = field->type;
        D.24031 = mono_type_size (D.23680, &align);
        size = (guint32) D.24031;
        D.24032 = class->sizes.class_size;
        field->offset = D.24032;
        D.23893 = field->offset;
        align.95 = align;
        D.24034 = align.95 + -1;
        D.24035 = D.23893 + D.24034;
        field->offset = D.24035;
        D.23893 = field->offset;
        align.95 = align;
        D.24036 = -align.95;
        D.24037 = D.23893 & D.24036;
        field->offset = D.24037;
        D.23893 = field->offset;
        D.23910 = (unsigned int) D.23893;
        D.24038 = D.23910 + size;
        D.24039 = (int) D.24038;
        class->sizes.class_size = D.24039;
      }
    finally
      {
        align = {CLOBBER};
      }
  }
  <D.18913>:
  i = i + 1;
  <D.18925>:
  if (i < top) goto <D.18924>; else goto <D.18923>;
  <D.18923>:
}


mono_class_has_references (struct MonoClass * klass)
{
  unsigned char D.24048;
  unsigned char D.24049;
  gboolean D.24052;
  <unnamed-unsigned:1> D.24053;

  D.24048 = BIT_FIELD_REF <*klass, 8, 160>;
  D.24049 = D.24048 & 2;
  if (D.24049 != 0) goto <D.24050>; else goto <D.24051>;
  <D.24050>:
  D.24052 = 1;
  return D.24052;
  <D.24051>:
  mono_class_init (klass);
  D.24053 = klass->has_references;
  D.24052 = (gboolean) D.24053;
  return D.24052;
}


mono_class_setup_methods (struct MonoClass * class)
{
  struct MonoMethod * * D.24055;
  struct MonoGenericClass * D.24060;
  unsigned char D.24063;
  gchar * D.24068;
  unsigned int D.24069;
  unsigned int D.24070;
  unsigned int D.24071;
  unsigned int D.24072;
  int D.24073;
  unsigned int i.96;
  unsigned int D.24075;
  struct MonoMethod * * D.24076;
  struct MonoGenericContext * D.24077;
  struct MonoMethod * * D.24078;
  struct MonoMethod * * D.24079;
  struct MonoMethod * D.24080;
  struct MonoMethod * D.24081;
  int D.24082;
  const char * D.24085;
  gchar * D.24086;
  unsigned int i.97;
  unsigned char D.24089;
  guint32 iftmp.98;
  int D.24096;
  _Bool D.24097;
  long int D.24098;
  long int D.24099;
  short unsigned int D.24102;
  int D.24105;
  int D.24106;
  unsigned int D.24107;
  unsigned int D.24108;
  unsigned int D.24109;
  int D.24110;
  unsigned int D.24111;
  struct MonoImage * D.24112;
  struct MonoClass * D.24113;
  struct MonoType * D.24114;
  struct MonoClass * D.24115;
  struct MonoType * D.24116;
  int D.24117;
  int method_num.99;
  unsigned int method_num.100;
  unsigned int D.24120;
  struct MonoMethod * * D.24121;
  int D.24124;
  unsigned int D.24125;
  int method_num.101;
  unsigned int method_num.102;
  unsigned int D.24128;
  struct MonoMethod * * D.24129;
  struct MonoClass * D.24130;
  struct MonoType * D.24131;
  int method_num.103;
  unsigned int method_num.104;
  unsigned int D.24134;
  struct MonoMethod * * D.24135;
  struct MonoType * D.24136;
  int method_num.105;
  unsigned int method_num.106;
  unsigned int D.24139;
  struct MonoMethod * * D.24140;
  int D.24141;
  unsigned int D.24142;
  int method_num.107;
  unsigned int method_num.108;
  unsigned int D.24145;
  struct MonoMethod * * D.24146;
  int D.24147;
  int D.24148;
  struct MonoClass * * D.24149;
  struct MonoClass * * D.24150;
  struct MonoClass * D.24151;
  unsigned int D.24153;
  unsigned int D.24154;
  unsigned int D.24155;
  unsigned int D.24156;
  int D.24157;
  unsigned int D.24158;
  struct MonoMethod * D.24159;
  unsigned int D.24162;
  unsigned int D.24163;
  unsigned char D.24165;
  struct MonoMethod * D.24167;
  short unsigned int D.24168;
  int D.24169;
  int D.24170;
  int slot.109;
  short int D.24174;
  int i;
  struct MonoMethod * * methods;

  D.24055 = class->methods;
  if (D.24055 != 0B) goto <D.24056>; else goto <D.24057>;
  <D.24056>:
  return;
  <D.24057>:
  mono_loader_lock ();
  D.24055 = class->methods;
  if (D.24055 != 0B) goto <D.24058>; else goto <D.24059>;
  <D.24058>:
  mono_loader_unlock ();
  return;
  <D.24059>:
  D.24060 = class->generic_class;
  if (D.24060 != 0B) goto <D.24061>; else goto <D.24062>;
  <D.24061>:
  {
    struct MonoError error;
    struct MonoClass * gklass;

    try
      {
        D.24060 = class->generic_class;
        gklass = D.24060->container_class;
        mono_class_init (gklass);
        D.24063 = gklass->exception_type;
        if (D.24063 == 0) goto <D.24064>; else goto <D.24065>;
        <D.24064>:
        mono_class_setup_methods (gklass);
        <D.24065>:
        D.24063 = gklass->exception_type;
        if (D.24063 != 0) goto <D.24066>; else goto <D.24067>;
        <D.24066>:
        D.24068 = monoeg_strdup ("Generic type definition failed to load");
        mono_class_set_failure (class, 7, D.24068);
        mono_loader_unlock ();
        return;
        <D.24067>:
        D.24069 = gklass->method.count;
        class->method.count = D.24069;
        D.24070 = class->method.count;
        D.24071 = D.24070 + 1;
        D.24072 = D.24071 * 4;
        D.24073 = (int) D.24072;
        methods = mono_class_alloc0 (class, D.24073);
        i = 0;
        goto <D.18941>;
        <D.18940>:
        i.96 = (unsigned int) i;
        D.24075 = i.96 * 4;
        D.24076 = methods + D.24075;
        D.24077 = mono_class_get_context (class);
        D.24078 = gklass->methods;
        i.96 = (unsigned int) i;
        D.24075 = i.96 * 4;
        D.24079 = D.24078 + D.24075;
        D.24080 = *D.24079;
        D.24081 = mono_class_inflate_generic_method_full_checked (D.24080, class, D.24077, &error);
        *D.24076 = D.24081;
        D.24082 = mono_error_ok (&error);
        if (D.24082 == 0) goto <D.24083>; else goto <D.24084>;
        <D.24083>:
        {
          char * method;

          D.24078 = gklass->methods;
          i.96 = (unsigned int) i;
          D.24075 = i.96 * 4;
          D.24079 = D.24078 + D.24075;
          D.24080 = *D.24079;
          method = mono_method_full_name (D.24080, 1);
          D.24085 = mono_error_get_message (&error);
          D.24086 = monoeg_g_strdup_printf ("Could not inflate method %s due to %s", method, D.24085);
          mono_class_set_failure (class, 7, D.24086);
          monoeg_g_free (method);
          mono_error_cleanup (&error);
          mono_loader_unlock ();
          return;
        }
        <D.24084>:
        i = i + 1;
        <D.18941>:
        i.97 = (unsigned int) i;
        D.24070 = class->method.count;
        if (i.97 < D.24070) goto <D.18940>; else goto <D.18942>;
        <D.18942>:
      }
    finally
      {
        error = {CLOBBER};
      }
  }
  goto <D.24088>;
  <D.24062>:
  D.24089 = class->rank;
  if (D.24089 != 0) goto <D.24090>; else goto <D.24091>;
  <D.24090>:
  {
    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.24089 = class->rank;
        if (D.24089 > 1) goto <D.24093>; else goto <D.24094>;
        <D.24093>:
        iftmp.98 = 5;
        goto <D.24095>;
        <D.24094>:
        iftmp.98 = 4;
        <D.24095>:
        class->method.count = iftmp.98;
        mono_class_setup_interfaces (class, &error);
        D.24096 = mono_error_ok (&error);
        D.24097 = D.24096 == 0;
        D.24098 = (long int) D.24097;
        D.24099 = __builtin_expect (D.24098, 0);
        if (D.24099 != 0) goto <D.24100>; else goto <D.24101>;
        <D.24100>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "class.c", 2088, "mono_error_ok (&error)");
        <D.24101>:
        D.24102 = class->interface_count;
        if (D.24102 != 0) goto <D.24103>; else goto <D.24104>;
        <D.24103>:
        count_generic = generic_array_methods (class);
        D.24070 = class->method.count;
        first_generic = (int) D.24070;
        D.24070 = class->method.count;
        D.24102 = class->interface_count;
        D.24105 = (int) D.24102;
        D.24106 = D.24105 * count_generic;
        D.24107 = (unsigned int) D.24106;
        D.24108 = D.24070 + D.24107;
        class->method.count = D.24108;
        <D.24104>:
        D.24070 = class->method.count;
        D.24109 = D.24070 * 4;
        D.24110 = (int) D.24109;
        methods = mono_class_alloc0 (class, D.24110);
        D.24089 = class->rank;
        D.24111 = (unsigned int) D.24089;
        D.24112 = class->image;
        sig = mono_metadata_signature_alloc (D.24112, D.24111);
        D.24113 = mono_defaults.void_class;
        D.24114 = &D.24113->byval_arg;
        sig->ret = D.24114;
        sig->pinvoke = 1;
        sig->hasthis = 1;
        i = 0;
        goto <D.18950>;
        <D.18949>:
        D.24115 = mono_defaults.int32_class;
        D.24116 = &D.24115->byval_arg;
        sig->params[i] = D.24116;
        i = i + 1;
        <D.18950>:
        D.24089 = class->rank;
        D.24117 = (int) D.24089;
        if (D.24117 > i) goto <D.18949>; else goto <D.18951>;
        <D.18951>:
        amethod = create_array_method (class, ".ctor", sig);
        method_num.99 = method_num;
        method_num = method_num.99 + 1;
        method_num.100 = (unsigned int) method_num.99;
        D.24120 = method_num.100 * 4;
        D.24121 = methods + D.24120;
        *D.24121 = amethod;
        D.24089 = class->rank;
        if (D.24089 > 1) goto <D.24122>; else goto <D.24123>;
        <D.24122>:
        D.24089 = class->rank;
        D.24117 = (int) D.24089;
        D.24124 = D.24117 * 2;
        D.24125 = (unsigned int) D.24124;
        D.24112 = class->image;
        sig = mono_metadata_signature_alloc (D.24112, D.24125);
        D.24113 = mono_defaults.void_class;
        D.24114 = &D.24113->byval_arg;
        sig->ret = D.24114;
        sig->pinvoke = 1;
        sig->hasthis = 1;
        i = 0;
        goto <D.18953>;
        <D.18952>:
        D.24115 = mono_defaults.int32_class;
        D.24116 = &D.24115->byval_arg;
        sig->params[i] = D.24116;
        i = i + 1;
        <D.18953>:
        D.24089 = class->rank;
        D.24117 = (int) D.24089;
        D.24124 = D.24117 * 2;
        if (D.24124 > i) goto <D.18952>; else goto <D.18954>;
        <D.18954>:
        amethod = create_array_method (class, ".ctor", sig);
        method_num.101 = method_num;
        method_num = method_num.101 + 1;
        method_num.102 = (unsigned int) method_num.101;
        D.24128 = method_num.102 * 4;
        D.24129 = methods + D.24128;
        *D.24129 = amethod;
        <D.24123>:
        D.24089 = class->rank;
        D.24111 = (unsigned int) D.24089;
        D.24112 = class->image;
        sig = mono_metadata_signature_alloc (D.24112, D.24111);
        D.24130 = class->element_class;
        D.24131 = &D.24130->byval_arg;
        sig->ret = D.24131;
        sig->pinvoke = 1;
        sig->hasthis = 1;
        i = 0;
        goto <D.18956>;
        <D.18955>:
        D.24115 = mono_defaults.int32_class;
        D.24116 = &D.24115->byval_arg;
        sig->params[i] = D.24116;
        i = i + 1;
        <D.18956>:
        D.24089 = class->rank;
        D.24117 = (int) D.24089;
        if (D.24117 > i) goto <D.18955>; else goto <D.18957>;
        <D.18957>:
        amethod = create_array_method (class, "Get", sig);
        method_num.103 = method_num;
        method_num = method_num.103 + 1;
        method_num.104 = (unsigned int) method_num.103;
        D.24134 = method_num.104 * 4;
        D.24135 = methods + D.24134;
        *D.24135 = amethod;
        D.24089 = class->rank;
        D.24111 = (unsigned int) D.24089;
        D.24112 = class->image;
        sig = mono_metadata_signature_alloc (D.24112, D.24111);
        D.24130 = class->element_class;
        D.24136 = &D.24130->this_arg;
        sig->ret = D.24136;
        sig->pinvoke = 1;
        sig->hasthis = 1;
        i = 0;
        goto <D.18959>;
        <D.18958>:
        D.24115 = mono_defaults.int32_class;
        D.24116 = &D.24115->byval_arg;
        sig->params[i] = D.24116;
        i = i + 1;
        <D.18959>:
        D.24089 = class->rank;
        D.24117 = (int) D.24089;
        if (D.24117 > i) goto <D.18958>; else goto <D.18960>;
        <D.18960>:
        amethod = create_array_method (class, "Address", sig);
        method_num.105 = method_num;
        method_num = method_num.105 + 1;
        method_num.106 = (unsigned int) method_num.105;
        D.24139 = method_num.106 * 4;
        D.24140 = methods + D.24139;
        *D.24140 = amethod;
        D.24089 = class->rank;
        D.24117 = (int) D.24089;
        D.24141 = D.24117 + 1;
        D.24142 = (unsigned int) D.24141;
        D.24112 = class->image;
        sig = mono_metadata_signature_alloc (D.24112, D.24142);
        D.24113 = mono_defaults.void_class;
        D.24114 = &D.24113->byval_arg;
        sig->ret = D.24114;
        sig->pinvoke = 1;
        sig->hasthis = 1;
        i = 0;
        goto <D.18962>;
        <D.18961>:
        D.24115 = mono_defaults.int32_class;
        D.24116 = &D.24115->byval_arg;
        sig->params[i] = D.24116;
        i = i + 1;
        <D.18962>:
        D.24089 = class->rank;
        D.24117 = (int) D.24089;
        if (D.24117 > i) goto <D.18961>; else goto <D.18963>;
        <D.18963>:
        D.24130 = class->element_class;
        D.24131 = &D.24130->byval_arg;
        sig->params[i] = D.24131;
        amethod = create_array_method (class, "Set", sig);
        method_num.107 = method_num;
        method_num = method_num.107 + 1;
        method_num.108 = (unsigned int) method_num.107;
        D.24145 = method_num.108 * 4;
        D.24146 = methods + D.24145;
        *D.24146 = amethod;
        i = 0;
        goto <D.18965>;
        <D.18964>:
        D.24147 = i * count_generic;
        D.24148 = D.24147 + first_generic;
        D.24149 = class->interfaces;
        i.96 = (unsigned int) i;
        D.24075 = i.96 * 4;
        D.24150 = D.24149 + D.24075;
        D.24151 = *D.24150;
        setup_generic_array_ifaces (class, D.24151, methods, D.24148);
        i = i + 1;
        <D.18965>:
        D.24102 = class->interface_count;
        D.24105 = (int) D.24102;
        if (D.24105 > i) goto <D.18964>; else goto <D.18966>;
        <D.18966>:
      }
    finally
      {
        error = {CLOBBER};
      }
  }
  goto <D.24152>;
  <D.24091>:
  D.24070 = class->method.count;
  D.24109 = D.24070 * 4;
  D.24110 = (int) D.24109;
  methods = mono_class_alloc (class, D.24110);
  i = 0;
  goto <D.18969>;
  <D.18968>:
  {
    int idx;

    D.24153 = class->method.first;
    i.97 = (unsigned int) i;
    D.24154 = D.24153 + i.97;
    D.24155 = D.24154 + 1;
    D.24112 = class->image;
    D.24156 = mono_metadata_translate_token_index (D.24112, 6, D.24155);
    idx = (int) D.24156;
    i.96 = (unsigned int) i;
    D.24075 = i.96 * 4;
    D.24076 = methods + D.24075;
    D.24157 = idx | 100663296;
    D.24158 = (unsigned int) D.24157;
    D.24112 = class->image;
    D.24159 = mono_get_method (D.24112, D.24158, class);
    *D.24076 = D.24159;
  }
  i = i + 1;
  <D.18969>:
  i.97 = (unsigned int) i;
  D.24070 = class->method.count;
  if (i.97 < D.24070) goto <D.18968>; else goto <D.18970>;
  <D.18970>:
  <D.24152>:
  <D.24088>:
  D.24162 = class->flags;
  D.24163 = D.24162 & 32;
  if (D.24163 != 0) goto <D.24160>; else goto <D.24164>;
  <D.24164>:
  D.24165 = class->byval_arg.type;
  if (D.24165 == 19) goto <D.24160>; else goto <D.24166>;
  <D.24166>:
  D.24165 = class->byval_arg.type;
  if (D.24165 == 30) goto <D.24160>; else goto <D.24161>;
  <D.24160>:
  {
    int slot;

    slot = 0;
    i = 0;
    goto <D.18973>;
    <D.18972>:
    i.96 = (unsigned int) i;
    D.24075 = i.96 * 4;
    D.24076 = methods + D.24075;
    D.24167 = *D.24076;
    D.24168 = D.24167->flags;
    D.24169 = (int) D.24168;
    D.24170 = D.24169 & 64;
    if (D.24170 != 0) goto <D.24171>; else goto <D.24172>;
    <D.24171>:
    i.96 = (unsigned int) i;
    D.24075 = i.96 * 4;
    D.24076 = methods + D.24075;
    D.24167 = *D.24076;
    slot.109 = slot;
    slot = slot.109 + 1;
    D.24174 = (short int) slot.109;
    D.24167->slot = D.24174;
    <D.24172>:
    i = i + 1;
    <D.18973>:
    i.97 = (unsigned int) i;
    D.24070 = class->method.count;
    if (i.97 < D.24070) goto <D.18972>; else goto <D.18974>;
    <D.18974>:
  }
  <D.24161>:
  mono_memory_barrier ();
  class->methods = methods;
  mono_loader_unlock ();
}


generic_array_methods (struct MonoClass * class)
{
  int generic_array_method_num.110;
  int D.24181;
  struct MonoClass * D.24182;
  unsigned char D.24183;
  _Bool D.24184;
  long int D.24185;
  long int D.24186;
  struct MonoMethod * * D.24189;
  unsigned int i.111;
  unsigned int D.24191;
  struct MonoMethod * * D.24192;
  const char * D.24193;
  int D.24194;
  unsigned int i.112;
  unsigned int D.24198;
  unsigned int count_generic.113;
  unsigned int D.24200;
  struct MonoImage * D.24201;
  void * generic_array_method_info.114;
  struct GenericArrayMethodInfo * generic_array_method_info.115;
  unsigned int D.24204;
  struct GenericArrayMethodInfo * D.24205;
  const char * D.24206;
  int D.24207;
  int D.24211;
  unsigned int D.24215;
  int D.24216;
  unsigned int D.24219;
  unsigned int D.24221;
  int D.24222;
  unsigned int D.24225;
  int D.24227;
  unsigned int D.24231;
  unsigned int D.24232;
  unsigned int D.24233;
  unsigned int D.24234;
  unsigned int D.24235;
  gchar * D.24236;
  int i;
  int count_generic;
  struct GList * list;
  struct GList * tmp;

  count_generic = 0;
  list = 0B;
  generic_array_method_num.110 = generic_array_method_num;
  if (generic_array_method_num.110 != 0) goto <D.24179>; else goto <D.24180>;
  <D.24179>:
  D.24181 = generic_array_method_num;
  return D.24181;
  <D.24180>:
  D.24182 = class->parent;
  mono_class_setup_methods (D.24182);
  D.24182 = class->parent;
  D.24183 = D.24182->exception_type;
  D.24184 = D.24183 != 0;
  D.24185 = (long int) D.24184;
  D.24186 = __builtin_expect (D.24185, 0);
  if (D.24186 != 0) goto <D.24187>; else goto <D.24188>;
  <D.24187>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "class.c", 4760, "!class->parent->exception_type");
  <D.24188>:
  i = 0;
  goto <D.19807>;
  <D.19806>:
  {
    struct MonoMethod * m;

    D.24182 = class->parent;
    D.24189 = D.24182->methods;
    i.111 = (unsigned int) i;
    D.24191 = i.111 * 4;
    D.24192 = D.24189 + D.24191;
    m = *D.24192;
    D.24193 = m->name;
    D.24194 = strncmp (D.24193, "InternalArray__", 15);
    if (D.24194 == 0) goto <D.24195>; else goto <D.24196>;
    <D.24195>:
    count_generic = count_generic + 1;
    list = monoeg_g_list_prepend (list, m);
    <D.24196>:
  }
  i = i + 1;
  <D.19807>:
  i.112 = (unsigned int) i;
  D.24182 = class->parent;
  D.24198 = D.24182->method.count;
  if (i.112 < D.24198) goto <D.19806>; else goto <D.19808>;
  <D.19808>:
  list = monoeg_g_list_reverse (list);
  count_generic.113 = (unsigned int) count_generic;
  D.24200 = count_generic.113 * 8;
  D.24201 = mono_defaults.corlib;
  generic_array_method_info.114 = mono_image_alloc (D.24201, D.24200);
  generic_array_method_info = generic_array_method_info.114;
  i = 0;
  tmp = list;
  goto <D.19861>;
  <D.19860>:
  {
    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.115 = generic_array_method_info;
    i.111 = (unsigned int) i;
    D.24204 = i.111 * 8;
    D.24205 = generic_array_method_info.115 + D.24204;
    D.24205->array_method = m;
    D.24206 = m->name;
    D.24207 = strncmp (D.24206, "InternalArray__ICollection_", 27);
    if (D.24207 == 0) goto <D.24208>; else goto <D.24209>;
    <D.24208>:
    iname = "System.Collections.Generic.ICollection`1.";
    D.24206 = m->name;
    mname = D.24206 + 27;
    goto <D.24210>;
    <D.24209>:
    D.24206 = m->name;
    D.24211 = strncmp (D.24206, "InternalArray__IEnumerable_", 27);
    if (D.24211 == 0) goto <D.24212>; else goto <D.24213>;
    <D.24212>:
    iname = "System.Collections.Generic.IEnumerable`1.";
    D.24206 = m->name;
    mname = D.24206 + 27;
    goto <D.24214>;
    <D.24213>:
    D.24215 = strlen (ireadonlylist_prefix);
    D.24206 = m->name;
    D.24216 = strncmp (D.24206, ireadonlylist_prefix, D.24215);
    if (D.24216 == 0) goto <D.24217>; else goto <D.24218>;
    <D.24217>:
    iname = "System.Collections.Generic.IReadOnlyList`1.";
    D.24206 = m->name;
    D.24219 = strlen (ireadonlylist_prefix);
    mname = D.24206 + D.24219;
    goto <D.24220>;
    <D.24218>:
    D.24221 = strlen (ireadonlycollection_prefix);
    D.24206 = m->name;
    D.24222 = strncmp (D.24206, ireadonlycollection_prefix, D.24221);
    if (D.24222 == 0) goto <D.24223>; else goto <D.24224>;
    <D.24223>:
    iname = "System.Collections.Generic.IReadOnlyCollection`1.";
    D.24206 = m->name;
    D.24225 = strlen (ireadonlycollection_prefix);
    mname = D.24206 + D.24225;
    goto <D.24226>;
    <D.24224>:
    D.24206 = m->name;
    D.24227 = strncmp (D.24206, "InternalArray__", 15);
    if (D.24227 == 0) goto <D.24228>; else goto <D.24229>;
    <D.24228>:
    iname = "System.Collections.Generic.IList`1.";
    D.24206 = m->name;
    mname = D.24206 + 15;
    goto <D.24230>;
    <D.24229>:
    monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "class.c", 4795);
    <D.24230>:
    <D.24226>:
    <D.24220>:
    <D.24214>:
    <D.24210>:
    D.24231 = strlen (iname);
    D.24232 = strlen (mname);
    D.24233 = D.24231 + D.24232;
    D.24234 = D.24233 + 1;
    D.24201 = mono_defaults.corlib;
    name = mono_image_alloc (D.24201, D.24234);
    strcpy (name, iname);
    D.24235 = strlen (iname);
    D.24236 = name + D.24235;
    strcpy (D.24236, mname);
    generic_array_method_info.115 = generic_array_method_info;
    i.111 = (unsigned int) i;
    D.24204 = i.111 * 8;
    D.24205 = generic_array_method_info.115 + D.24204;
    D.24205->name = name;
    i = i + 1;
  }
  tmp = tmp->next;
  <D.19861>:
  if (tmp != 0B) goto <D.19860>; else goto <D.19862>;
  <D.19862>:
  generic_array_method_num = count_generic;
  monoeg_g_list_free (list);
  D.24181 = generic_array_method_num;
  return D.24181;
}


strcpy (char * restrict __dest, const char * restrict __src)
{
  char * D.24238;
  unsigned int D.24239;

  D.24239 = __builtin_object_size (__dest, 1);
  D.24238 = __builtin___strcpy_chk (__dest, __src, D.24239);
  return D.24238;
}


create_array_method (struct MonoClass * class, const char * name, struct MonoMethodSignature * sig)
{
  struct MonoImage * D.24241;
  char D.24242;
  short unsigned int D.24245;
  short unsigned int D.24246;
  short unsigned int D.24248;
  short unsigned int D.24249;
  struct MonoMethod * D.24250;
  struct MonoMethod * method;

  D.24241 = class->image;
  method = mono_image_alloc0 (D.24241, 32);
  method->klass = class;
  method->flags = 6;
  method->iflags = 4096;
  method->signature = sig;
  method->name = name;
  method->slot = -1;
  D.24242 = *name;
  if (D.24242 == 46) goto <D.24243>; else goto <D.24244>;
  <D.24243>:
  D.24245 = method->flags;
  D.24246 = D.24245 | 6144;
  method->flags = D.24246;
  goto <D.24247>;
  <D.24244>:
  D.24248 = method->iflags;
  D.24249 = D.24248 | 3;
  method->iflags = D.24249;
  <D.24247>:
  D.24250 = method;
  return D.24250;
}


setup_generic_array_ifaces (struct MonoClass * class, struct MonoClass * iface, struct MonoMethod * * methods, int pos)
{
  struct MonoGenericClass * D.24252;
  struct MonoGenericInst * D.24253;
  struct GenericArrayMethodInfo * generic_array_method_info.116;
  unsigned int i.117;
  unsigned int D.24256;
  struct GenericArrayMethodInfo * D.24257;
  int pos.118;
  unsigned int pos.119;
  unsigned int D.24260;
  struct MonoMethod * * D.24261;
  char * D.24262;
  struct MonoMethod * D.24263;
  int generic_array_method_num.120;
  struct MonoGenericContext tmp_context;
  int i;

  try
    {
      tmp_context.class_inst = 0B;
      D.24252 = iface->generic_class;
      D.24253 = D.24252->context.class_inst;
      tmp_context.method_inst = D.24253;
      i = 0;
      goto <D.19874>;
      <D.19873>:
      {
        struct MonoMethod * m;
        struct MonoMethod * inflated;

        generic_array_method_info.116 = generic_array_method_info;
        i.117 = (unsigned int) i;
        D.24256 = i.117 * 8;
        D.24257 = generic_array_method_info.116 + D.24256;
        m = D.24257->array_method;
        inflated = mono_class_inflate_generic_method (m, &tmp_context);
        pos.118 = pos;
        pos = pos.118 + 1;
        pos.119 = (unsigned int) pos.118;
        D.24260 = pos.119 * 4;
        D.24261 = methods + D.24260;
        generic_array_method_info.116 = generic_array_method_info;
        i.117 = (unsigned int) i;
        D.24256 = i.117 * 8;
        D.24257 = generic_array_method_info.116 + D.24256;
        D.24262 = D.24257->name;
        D.24263 = mono_marshal_get_generic_array_helper (class, iface, D.24262, inflated);
        *D.24261 = D.24263;
      }
      i = i + 1;
      <D.19874>:
      generic_array_method_num.120 = generic_array_method_num;
      if (i < generic_array_method_num.120) goto <D.19873>; else goto <D.19875>;
      <D.19875>:
    }
  finally
    {
      tmp_context = {CLOBBER};
    }
}


mono_class_get_method_by_index (struct MonoClass * class, int index)
{
  struct MonoGenericClass * D.24266;
  struct MonoMethod * * D.24268;
  struct MonoGenericContext * D.24270;
  struct MonoMethod * * D.24271;
  unsigned int index.121;
  unsigned int D.24273;
  struct MonoMethod * * D.24274;
  struct MonoMethod * D.24275;
  struct MonoMethod * D.24276;
  unsigned char D.24277;
  int iftmp.122;
  unsigned int index.123;
  unsigned int D.24286;
  _Bool D.24287;
  long int D.24288;
  long int D.24289;
  struct MonoMethod * * D.24292;

  D.24266 = class->generic_class;
  if (D.24266 != 0B) goto <D.24267>; else goto <D.24265>;
  <D.24267>:
  D.24268 = class->methods;
  if (D.24268 == 0B) goto <D.24269>; else goto <D.24265>;
  <D.24269>:
  {
    struct MonoClass * gklass;
    struct MonoMethod * m;

    D.24266 = class->generic_class;
    gklass = D.24266->container_class;
    D.24270 = mono_class_get_context (class);
    D.24271 = gklass->methods;
    index.121 = (unsigned int) index;
    D.24273 = index.121 * 4;
    D.24274 = D.24271 + D.24273;
    D.24275 = *D.24274;
    m = mono_class_inflate_generic_method_full (D.24275, class, D.24270);
    D.24276 = m;
    return D.24276;
  }
  <D.24265>:
  mono_class_setup_methods (class);
  D.24277 = class->exception_type;
  if (D.24277 != 0) goto <D.24278>; else goto <D.24279>;
  <D.24278>:
  D.24276 = 0B;
  return D.24276;
  <D.24279>:
  if (index < 0) goto <D.24281>; else goto <D.24284>;
  <D.24284>:
  index.123 = (unsigned int) index;
  D.24286 = class->method.count;
  if (index.123 >= D.24286) goto <D.24281>; else goto <D.24282>;
  <D.24281>:
  iftmp.122 = 1;
  goto <D.24283>;
  <D.24282>:
  iftmp.122 = 0;
  <D.24283>:
  D.24287 = iftmp.122 != 0;
  D.24288 = (long int) D.24287;
  D.24289 = __builtin_expect (D.24288, 0);
  if (D.24289 != 0) goto <D.24290>; else goto <D.24291>;
  <D.24290>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "class.c", 2205, "index >= 0 && index < class->method.count");
  <D.24291>:
  D.24268 = class->methods;
  index.121 = (unsigned int) index;
  D.24273 = index.121 * 4;
  D.24292 = D.24268 + D.24273;
  D.24276 = *D.24292;
  return D.24276;
}


mono_class_get_inflated_method (struct MonoClass * class, struct MonoMethod * method)
{
  struct MonoGenericClass * D.24294;
  struct MonoClass * D.24295;
  _Bool D.24296;
  long int D.24297;
  long int D.24298;
  unsigned char D.24301;
  _Bool D.24302;
  long int D.24303;
  long int D.24304;
  struct MonoMethod * * D.24307;
  unsigned int i.124;
  unsigned int D.24309;
  struct MonoMethod * * D.24310;
  struct MonoMethod * D.24311;
  struct MonoMethod * * D.24314;
  struct MonoMethod * D.24317;
  struct MonoMethod * * D.24318;
  struct MonoGenericContext * D.24319;
  unsigned int i.125;
  unsigned int D.24321;
  struct MonoClass * gklass;
  int i;

  D.24294 = class->generic_class;
  gklass = D.24294->container_class;
  D.24295 = method->klass;
  D.24296 = D.24295 != gklass;
  D.24297 = (long int) D.24296;
  D.24298 = __builtin_expect (D.24297, 0);
  if (D.24298 != 0) goto <D.24299>; else goto <D.24300>;
  <D.24299>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "class.c", 2222, "method->klass == gklass");
  <D.24300>:
  mono_class_setup_methods (gklass);
  D.24301 = gklass->exception_type;
  D.24302 = D.24301 != 0;
  D.24303 = (long int) D.24302;
  D.24304 = __builtin_expect (D.24303, 0);
  if (D.24304 != 0) goto <D.24305>; else goto <D.24306>;
  <D.24305>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "class.c", 2225, "!gklass->exception_type");
  <D.24306>:
  i = 0;
  goto <D.18988>;
  <D.18987>:
  D.24307 = gklass->methods;
  i.124 = (unsigned int) i;
  D.24309 = i.124 * 4;
  D.24310 = D.24307 + D.24309;
  D.24311 = *D.24310;
  if (D.24311 == method) goto <D.24312>; else goto <D.24313>;
  <D.24312>:
  D.24314 = class->methods;
  if (D.24314 != 0B) goto <D.24315>; else goto <D.24316>;
  <D.24315>:
  D.24314 = class->methods;
  i.124 = (unsigned int) i;
  D.24309 = i.124 * 4;
  D.24318 = D.24314 + D.24309;
  D.24317 = *D.24318;
  return D.24317;
  <D.24316>:
  D.24319 = mono_class_get_context (class);
  D.24307 = gklass->methods;
  i.124 = (unsigned int) i;
  D.24309 = i.124 * 4;
  D.24310 = D.24307 + D.24309;
  D.24311 = *D.24310;
  D.24317 = mono_class_inflate_generic_method_full (D.24311, class, D.24319);
  return D.24317;
  <D.24313>:
  i = i + 1;
  <D.18988>:
  i.125 = (unsigned int) i;
  D.24321 = gklass->method.count;
  if (i.125 < D.24321) goto <D.18987>; else goto <D.18989>;
  <D.18989>:
  D.24317 = 0B;
  return D.24317;
}


mono_class_get_vtable_entry (struct MonoClass * class, int offset)
{
  unsigned char D.24323;
  struct MonoClass * D.24326;
  int D.24327;
  struct MonoMethod * D.24330;
  struct MonoMethod * * D.24331;
  unsigned int offset.126;
  unsigned int D.24333;
  struct MonoMethod * * D.24334;
  struct MonoGenericClass * D.24335;
  struct MonoMethod * * D.24338;
  struct MonoMethod * * D.24339;
  struct MonoGenericContext * D.24340;
  unsigned char D.24342;
  struct MonoMethod * * D.24345;
  struct MonoMethod * * D.24346;
  struct MonoMethod * m;

  D.24323 = class->rank;
  if (D.24323 == 1) goto <D.24324>; else goto <D.24325>;
  <D.24324>:
  D.24326 = class->parent;
  mono_class_setup_vtable (D.24326);
  D.24326 = class->parent;
  D.24327 = D.24326->vtable_size;
  if (D.24327 > offset) goto <D.24328>; else goto <D.24329>;
  <D.24328>:
  D.24326 = class->parent;
  D.24331 = D.24326->vtable;
  offset.126 = (unsigned int) offset;
  D.24333 = offset.126 * 4;
  D.24334 = D.24331 + D.24333;
  D.24330 = *D.24334;
  return D.24330;
  <D.24329>:
  <D.24325>:
  D.24335 = class->generic_class;
  if (D.24335 != 0B) goto <D.24336>; else goto <D.24337>;
  <D.24336>:
  {
    struct MonoClass * gklass;

    D.24335 = class->generic_class;
    gklass = D.24335->container_class;
    mono_class_setup_vtable (gklass);
    D.24338 = gklass->vtable;
    offset.126 = (unsigned int) offset;
    D.24333 = offset.126 * 4;
    D.24339 = D.24338 + D.24333;
    m = *D.24339;
    D.24340 = mono_class_get_context (class);
    m = mono_class_inflate_generic_method_full (m, class, D.24340);
  }
  goto <D.24341>;
  <D.24337>:
  mono_class_setup_vtable (class);
  D.24342 = class->exception_type;
  if (D.24342 != 0) goto <D.24343>; else goto <D.24344>;
  <D.24343>:
  D.24330 = 0B;
  return D.24330;
  <D.24344>:
  D.24345 = class->vtable;
  offset.126 = (unsigned int) offset;
  D.24333 = offset.126 * 4;
  D.24346 = D.24345 + D.24333;
  m = *D.24346;
  <D.24341>:
  D.24330 = m;
  return D.24330;
}


mono_class_get_vtable_size (struct MonoClass * klass)
{
  int D.24348;

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


mono_unload_interface_ids (struct MonoBitSet * bitset)
{
  struct MonoBitSet * global_interface_bitset.127;

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


mono_unload_interface_id (struct MonoClass * class)
{
  struct MonoBitSet * global_interface_bitset.128;
  short unsigned int D.24354;
  unsigned int D.24357;

  global_interface_bitset.128 = global_interface_bitset;
  if (global_interface_bitset.128 != 0B) goto <D.24352>; else goto <D.24353>;
  <D.24352>:
  D.24354 = class->interface_id;
  if (D.24354 != 0) goto <D.24355>; else goto <D.24356>;
  <D.24355>:
  mono_loader_lock ();
  D.24354 = class->interface_id;
  D.24357 = (unsigned int) D.24354;
  global_interface_bitset.128 = global_interface_bitset;
  mono_bitset_clear (global_interface_bitset.128, D.24357);
  mono_loader_unlock ();
  <D.24356>:
  <D.24353>:
}


mono_class_get_implemented_interfaces (struct MonoClass * klass, struct MonoError * error)
{
  int D.24358;
  struct GPtrArray * res.129;
  struct GPtrArray * D.24364;
  struct GPtrArray * res;

  try
    {
      res = 0B;
      collect_implemented_interfaces_aux (klass, &res, error);
      D.24358 = mono_error_ok (error);
      if (D.24358 == 0) goto <D.24359>; else goto <D.24360>;
      <D.24359>:
      res.129 = res;
      if (res.129 != 0B) goto <D.24362>; else goto <D.24363>;
      <D.24362>:
      res.129 = res;
      monoeg_g_ptr_array_free (res.129, 1);
      <D.24363>:
      D.24364 = 0B;
      return D.24364;
      <D.24360>:
      D.24364 = res;
      return D.24364;
    }
  finally
    {
      res = {CLOBBER};
    }
}


collect_implemented_interfaces_aux (struct MonoClass * klass, struct GPtrArray * * res, struct MonoError * error)
{
  int D.24367;
  struct MonoClass * * D.24370;
  unsigned int i.130;
  unsigned int D.24372;
  struct MonoClass * * D.24373;
  struct GPtrArray * D.24374;
  struct GPtrArray * D.24377;
  unsigned char D.24378;
  int D.24381;
  short unsigned int D.24384;
  int D.24385;
  int i;
  struct MonoClass * ic;

  mono_class_setup_interfaces (klass, error);
  D.24367 = mono_error_ok (error);
  if (D.24367 == 0) goto <D.24368>; else goto <D.24369>;
  <D.24368>:
  return;
  <D.24369>:
  i = 0;
  goto <D.19104>;
  <D.19103>:
  D.24370 = klass->interfaces;
  i.130 = (unsigned int) i;
  D.24372 = i.130 * 4;
  D.24373 = D.24370 + D.24372;
  ic = *D.24373;
  D.24374 = *res;
  if (D.24374 == 0B) goto <D.24375>; else goto <D.24376>;
  <D.24375>:
  D.24377 = monoeg_g_ptr_array_new ();
  *res = D.24377;
  <D.24376>:
  D.24374 = *res;
  monoeg_g_ptr_array_add (D.24374, ic);
  mono_class_init (ic);
  D.24378 = ic->exception_type;
  if (D.24378 != 0) goto <D.24379>; else goto <D.24380>;
  <D.24379>:
  mono_error_set_type_load_class (error, ic, "Error Loading class");
  return;
  <D.24380>:
  collect_implemented_interfaces_aux (ic, res, error);
  D.24381 = mono_error_ok (error);
  if (D.24381 == 0) goto <D.24382>; else goto <D.24383>;
  <D.24382>:
  return;
  <D.24383>:
  i = i + 1;
  <D.19104>:
  D.24384 = klass->interface_count;
  D.24385 = (int) D.24384;
  if (D.24385 > i) goto <D.19103>; else goto <D.19105>;
  <D.19105>:
}


mono_class_interface_offset (struct MonoClass * klass, struct MonoClass * itf)
{
  short unsigned int D.24387;
  unsigned int D.24388;
  struct MonoClass * * D.24389;
  int D.24392;
  guint16 * D.24393;
  int result.131;
  int D.24395;
  int D.24396;
  int D.24397;
  unsigned int D.24398;
  unsigned int D.24399;
  guint16 * D.24400;
  short unsigned int D.24401;
  struct MonoClass * * result;

  D.24387 = klass->interface_offsets_count;
  D.24388 = (unsigned int) D.24387;
  D.24389 = klass->interfaces_packed;
  result = mono_binary_search (itf, D.24389, D.24388, 4, compare_interface_ids);
  if (result != 0B) goto <D.24390>; else goto <D.24391>;
  <D.24390>:
  D.24393 = klass->interface_offsets_packed;
  result.131 = (int) result;
  D.24389 = klass->interfaces_packed;
  D.24395 = (int) D.24389;
  D.24396 = result.131 - D.24395;
  D.24397 = D.24396 /[ex] 4;
  D.24398 = (unsigned int) D.24397;
  D.24399 = D.24398 * 2;
  D.24400 = D.24393 + D.24399;
  D.24401 = *D.24400;
  D.24392 = (int) D.24401;
  return D.24392;
  <D.24391>:
  D.24392 = -1;
  return D.24392;
}


compare_interface_ids (const void * p_key, const void * p_element)
{
  int D.24403;
  short unsigned int D.24404;
  int D.24405;
  short unsigned int D.24406;
  int D.24407;
  const struct MonoClass * key;
  const struct MonoClass * element;

  key = p_key;
  element = MEM[(struct MonoClass * *)p_element];
  D.24404 = key->interface_id;
  D.24405 = (int) D.24404;
  D.24406 = element->interface_id;
  D.24407 = (int) D.24406;
  D.24403 = D.24405 - D.24407;
  return D.24403;
}


mono_class_interface_offset_with_variance (struct MonoClass * klass, struct MonoClass * itf, gboolean * non_exact_match)
{
  int D.24411;
  int D.24412;
  struct MonoClass * * D.24415;
  unsigned int i.132;
  unsigned int D.24417;
  struct MonoClass * * D.24418;
  struct MonoClass * D.24419;
  int D.24420;
  guint16 * D.24423;
  unsigned int D.24424;
  guint16 * D.24425;
  short unsigned int D.24426;
  short unsigned int D.24427;
  int D.24428;
  int i;

  i = mono_class_interface_offset (klass, itf);
  *non_exact_match = 0;
  if (i >= 0) goto <D.24409>; else goto <D.24410>;
  <D.24409>:
  D.24411 = i;
  return D.24411;
  <D.24410>:
  D.24412 = mono_class_has_variant_generic_params (itf);
  if (D.24412 == 0) goto <D.24413>; else goto <D.24414>;
  <D.24413>:
  D.24411 = -1;
  return D.24411;
  <D.24414>:
  i = 0;
  goto <D.19129>;
  <D.19128>:
  D.24415 = klass->interfaces_packed;
  i.132 = (unsigned int) i;
  D.24417 = i.132 * 4;
  D.24418 = D.24415 + D.24417;
  D.24419 = *D.24418;
  D.24420 = mono_class_is_variant_compatible (itf, D.24419, 0);
  if (D.24420 != 0) goto <D.24421>; else goto <D.24422>;
  <D.24421>:
  *non_exact_match = 1;
  D.24423 = klass->interface_offsets_packed;
  i.132 = (unsigned int) i;
  D.24424 = i.132 * 2;
  D.24425 = D.24423 + D.24424;
  D.24426 = *D.24425;
  D.24411 = (int) D.24426;
  return D.24411;
  <D.24422>:
  i = i + 1;
  <D.19129>:
  D.24427 = klass->interface_offsets_count;
  D.24428 = (int) D.24427;
  if (D.24428 > i) goto <D.19128>; else goto <D.19130>;
  <D.19130>:
  D.24411 = -1;
  return D.24411;
}


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.24430;
  unsigned int D.24431;
  unsigned int D.24432;
  struct MonoClass * * D.24433;
  unsigned int j.133;
  unsigned int D.24435;
  struct MonoClass * * D.24436;
  short unsigned int D.24437;
  int D.24438;
  struct MonoClass * * D.24439;
  unsigned int i.134;
  unsigned int D.24441;
  struct MonoClass * * D.24442;
  unsigned char D.24443;
  unsigned char D.24444;
  short unsigned int D.24447;
  int D.24448;
  int D.24451;
  const char * D.24454;
  gchar * D.24455;
  unsigned int D.24458;
  unsigned int num_ifaces.135;
  unsigned int D.24460;
  void * * D.24461;
  void * * D.24462;
  unsigned int i.136;
  struct GPtrArray * * D.24466;
  int D.24467;
  struct MonoClass * * D.24468;
  int num_array_interfaces.137;
  unsigned int D.24474;
  unsigned int D.24475;
  unsigned char D.24477;
  short unsigned int D.24479;
  int D.24480;
  short unsigned int D.24483;
  unsigned int num_ifaces.138;
  unsigned int D.24485;
  int * D.24486;
  _Bool D.24489;
  long int D.24490;
  long int D.24491;
  int D.24494;
  sizetype D.24495;
  sizetype D.24496;
  sizetype D.24497;
  struct MonoClass * * D.24498;
  struct MonoClass * D.24499;
  _Bool D.24500;
  long int D.24501;
  long int D.24502;
  struct GPtrArray * * D.24505;
  int D.24508;
  gchar * D.24513;
  int is_enumerator.139;
  struct MonoClass * * D.24523;
  unsigned int ienumerator_idx.140;
  unsigned int D.24525;
  struct MonoClass * * D.24526;
  struct MonoClass * D.24527;
  _Bool D.24528;
  long int D.24529;
  long int D.24530;
  int D.19345;
  int iftmp.141;
  int D.19344;
  const char[14] * D.24536;
  unsigned char D.24537;
  int D.24538;
  unsigned char D.24539;
  int D.24540;
  _Bool D.24541;
  _Bool D.24542;
  _Bool D.24543;
  const unsigned char * D.24546;
  unsigned char D.24547;
  int D.24548;
  const unsigned char * D.24549;
  unsigned char D.24550;
  int D.24551;
  _Bool D.24552;
  _Bool D.24553;
  const unsigned char * D.24556;
  unsigned char D.24557;
  int D.24558;
  const unsigned char * D.24559;
  unsigned char D.24560;
  int D.24561;
  _Bool D.24562;
  _Bool D.24563;
  const unsigned char * D.24566;
  unsigned char D.24567;
  int D.24568;
  const unsigned char * D.24569;
  unsigned char D.24570;
  int D.24571;
  const char * D.24573;
  unsigned int ilist_iface_idx.142;
  unsigned int D.24579;
  struct MonoClass * * D.24580;
  struct MonoClass * iftmp.143;
  unsigned int ireadonlylist_iface_idx.144;
  unsigned int D.24585;
  struct MonoClass * * D.24586;
  int iftmp.145;
  struct MonoClass * D.24592;
  struct MonoClass * * D.24593;
  unsigned int icollection_iface_idx.146;
  unsigned int D.24595;
  struct MonoClass * * D.24596;
  struct MonoClass * D.24597;
  unsigned int ienumerable_iface_idx.147;
  unsigned int D.24599;
  struct MonoClass * * D.24600;
  struct MonoClass * D.24601;
  int iftmp.148;
  struct MonoClass * D.24605;
  int iftmp.149;
  struct MonoClass * * D.24610;
  unsigned int ireadonlycollection_iface_idx.150;
  unsigned int D.24612;
  struct MonoClass * * D.24613;
  struct MonoClass * D.24614;
  int iftmp.151;
  _Bool D.24620;
  _Bool D.24621;
  _Bool D.24622;
  _Bool D.24624;
  long int D.24625;
  long int D.24626;
  struct MonoGenericClass * D.24629;
  struct MonoClass * D.24630;
  struct MonoClass * D.24631;
  int D.19370;
  int iftmp.152;
  int D.19369;
  const char[14] * D.24638;
  unsigned char D.24639;
  int D.24640;
  unsigned char D.24641;
  int D.24642;
  _Bool D.24643;
  _Bool D.24644;
  _Bool D.24645;
  const unsigned char * D.24648;
  unsigned char D.24649;
  int D.24650;
  const unsigned char * D.24651;
  unsigned char D.24652;
  int D.24653;
  _Bool D.24654;
  _Bool D.24655;
  const unsigned char * D.24658;
  unsigned char D.24659;
  int D.24660;
  const unsigned char * D.24661;
  unsigned char D.24662;
  int D.24663;
  _Bool D.24664;
  _Bool D.24665;
  const unsigned char * D.24668;
  unsigned char D.24669;
  int D.24670;
  const unsigned char * D.24671;
  unsigned char D.24672;
  int D.24673;
  int D.19379;
  int iftmp.153;
  int D.19378;
  const char[14] * D.24681;
  unsigned char D.24682;
  int D.24683;
  unsigned char D.24684;
  int D.24685;
  _Bool D.24686;
  _Bool D.24687;
  _Bool D.24688;
  const unsigned char * D.24691;
  unsigned char D.24692;
  int D.24693;
  const unsigned char * D.24694;
  unsigned char D.24695;
  int D.24696;
  _Bool D.24697;
  _Bool D.24698;
  const unsigned char * D.24701;
  unsigned char D.24702;
  int D.24703;
  const unsigned char * D.24704;
  unsigned char D.24705;
  int D.24706;
  _Bool D.24707;
  _Bool D.24708;
  const unsigned char * D.24711;
  unsigned char D.24712;
  int D.24713;
  const unsigned char * D.24714;
  unsigned char D.24715;
  int D.24716;
  int D.19388;
  int iftmp.154;
  int D.19387;
  const char[16] * D.24724;
  unsigned char D.24725;
  int D.24726;
  unsigned char D.24727;
  int D.24728;
  _Bool D.24729;
  _Bool D.24730;
  _Bool D.24731;
  const unsigned char * D.24734;
  unsigned char D.24735;
  int D.24736;
  const unsigned char * D.24737;
  unsigned char D.24738;
  int D.24739;
  _Bool D.24740;
  _Bool D.24741;
  const unsigned char * D.24744;
  unsigned char D.24745;
  int D.24746;
  const unsigned char * D.24747;
  unsigned char D.24748;
  int D.24749;
  _Bool D.24750;
  _Bool D.24751;
  const unsigned char * D.24754;
  unsigned char D.24755;
  int D.24756;
  const unsigned char * D.24757;
  unsigned char D.24758;
  int D.24759;
  int D.19397;
  int iftmp.155;
  int D.19396;
  const char[22] * D.24767;
  unsigned char D.24768;
  int D.24769;
  unsigned char D.24770;
  int D.24771;
  _Bool D.24772;
  _Bool D.24773;
  _Bool D.24774;
  const unsigned char * D.24777;
  unsigned char D.24778;
  int D.24779;
  const unsigned char * D.24780;
  unsigned char D.24781;
  int D.24782;
  _Bool D.24783;
  _Bool D.24784;
  const unsigned char * D.24787;
  unsigned char D.24788;
  int D.24789;
  const unsigned char * D.24790;
  unsigned char D.24791;
  int D.24792;
  _Bool D.24793;
  _Bool D.24794;
  const unsigned char * D.24797;
  unsigned char D.24798;
  int D.24799;
  const unsigned char * D.24800;
  unsigned char D.24801;
  int D.24802;
  int D.24807;
  struct MonoClass * * D.24812;
  short unsigned int D.24815;
  int D.24816;
  _Bool D.24817;
  long int D.24818;
  long int D.24819;
  short unsigned int D.24822;
  unsigned int interface_offsets_count.156;
  unsigned int D.24824;
  int D.24825;
  void * D.24826;
  unsigned int D.24827;
  int D.24828;
  void * D.24829;
  int D.24830;
  int D.24831;
  unsigned int D.24832;
  unsigned int iftmp.157;
  int D.24834;
  unsigned int D.24838;
  struct MonoClass * * D.24839;
  struct MonoClass * D.24840;
  short unsigned int D.24841;
  int D.24842;
  sizetype D.24843;
  uint8_t * D.24844;
  unsigned char D.24845;
  signed char D.24846;
  int D.24847;
  int D.24848;
  signed char D.24849;
  signed char D.24850;
  unsigned char D.24851;
  struct MonoClass * * D.24852;
  guint16 * D.24853;
  unsigned int D.24854;
  guint16 * D.24855;
  short unsigned int D.24856;
  struct GPtrArray * * D.24857;
  int D.24860;
  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.24430 = class->idepth;
      D.24431 = (unsigned int) D.24430;
      D.24432 = D.24431 * 4;
      ifaces_array = monoeg_malloc0 (D.24432);
      j = 0;
      goto <D.19314>;
      <D.19313>:
      D.24433 = class->supertypes;
      j.133 = (unsigned int) j;
      D.24435 = j.133 * 4;
      D.24436 = D.24433 + D.24435;
      k = *D.24436;
      D.24437 = k->interface_count;
      D.24438 = (int) D.24437;
      num_ifaces = D.24438 + num_ifaces;
      i = 0;
      goto <D.19306>;
      <D.19305>:
      D.24439 = k->interfaces;
      i.134 = (unsigned int) i;
      D.24441 = i.134 * 4;
      D.24442 = D.24439 + D.24441;
      ic = *D.24442;
      D.24443 = BIT_FIELD_REF <*ic, 8, 160>;
      D.24444 = D.24443 & 1;
      if (D.24444 == 0) goto <D.24445>; else goto <D.24446>;
      <D.24445>:
      mono_class_init (ic);
      <D.24446>:
      D.24447 = ic->interface_id;
      D.24448 = (int) D.24447;
      if (D.24448 > max_iid) goto <D.24449>; else goto <D.24450>;
      <D.24449>:
      D.24447 = ic->interface_id;
      max_iid = (int) D.24447;
      <D.24450>:
      i = i + 1;
      <D.19306>:
      D.24437 = k->interface_count;
      D.24438 = (int) D.24437;
      if (D.24438 > i) goto <D.19305>; else goto <D.19307>;
      <D.19307>:
      ifaces = mono_class_get_implemented_interfaces (k, &error);
      D.24451 = mono_error_ok (&error);
      if (D.24451 == 0) goto <D.24452>; else goto <D.24453>;
      <D.24452>:
      {
        char * name;

        name = mono_type_get_full_name (k);
        D.24454 = mono_error_get_message (&error);
        D.24455 = monoeg_g_strdup_printf ("Error getting the interfaces of %s due to %s", name, D.24454);
        mono_class_set_failure (class, 7, D.24455);
        monoeg_g_free (name);
        mono_error_cleanup (&error);
        cur_slot = -1;
        goto end;
      }
      <D.24453>:
      if (ifaces != 0B) goto <D.24456>; else goto <D.24457>;
      <D.24456>:
      D.24458 = ifaces->len;
      num_ifaces.135 = (unsigned int) num_ifaces;
      D.24460 = D.24458 + num_ifaces.135;
      num_ifaces = (int) D.24460;
      i = 0;
      goto <D.19311>;
      <D.19310>:
      D.24461 = ifaces->pdata;
      i.134 = (unsigned int) i;
      D.24441 = i.134 * 4;
      D.24462 = D.24461 + D.24441;
      ic = *D.24462;
      D.24447 = ic->interface_id;
      D.24448 = (int) D.24447;
      if (D.24448 > max_iid) goto <D.24463>; else goto <D.24464>;
      <D.24463>:
      D.24447 = ic->interface_id;
      max_iid = (int) D.24447;
      <D.24464>:
      i = i + 1;
      <D.19311>:
      i.136 = (unsigned int) i;
      D.24458 = ifaces->len;
      if (i.136 < D.24458) goto <D.19310>; else goto <D.19312>;
      <D.19312>:
      j.133 = (unsigned int) j;
      D.24435 = j.133 * 4;
      D.24466 = ifaces_array + D.24435;
      *D.24466 = ifaces;
      <D.24457>:
      j = j + 1;
      <D.19314>:
      D.24430 = class->idepth;
      D.24467 = (int) D.24430;
      if (D.24467 > j) goto <D.19313>; else goto <D.19315>;
      <D.19315>:
      i = 0;
      goto <D.19317>;
      <D.19316>:
      i.134 = (unsigned int) i;
      D.24441 = i.134 * 4;
      D.24468 = array_interfaces + D.24441;
      ic = *D.24468;
      mono_class_init (ic);
      D.24447 = ic->interface_id;
      D.24448 = (int) D.24447;
      if (D.24448 > max_iid) goto <D.24469>; else goto <D.24470>;
      <D.24469>:
      D.24447 = ic->interface_id;
      max_iid = (int) D.24447;
      <D.24470>:
      i = i + 1;
      <D.19317>:
      num_array_interfaces.137 = num_array_interfaces;
      if (i < num_array_interfaces.137) goto <D.19316>; else goto <D.19318>;
      <D.19318>:
      D.24474 = class->flags;
      D.24475 = D.24474 & 32;
      if (D.24475 != 0) goto <D.24472>; else goto <D.24476>;
      <D.24476>:
      D.24477 = class->byval_arg.type;
      if (D.24477 == 19) goto <D.24472>; else goto <D.24478>;
      <D.24478>:
      D.24477 = class->byval_arg.type;
      if (D.24477 == 30) goto <D.24472>; else goto <D.24473>;
      <D.24472>:
      num_ifaces = num_ifaces + 1;
      D.24479 = class->interface_id;
      D.24480 = (int) D.24479;
      if (D.24480 > max_iid) goto <D.24481>; else goto <D.24482>;
      <D.24481>:
      D.24479 = class->interface_id;
      max_iid = (int) D.24479;
      <D.24482>:
      <D.24473>:
      D.24483 = (short unsigned int) max_iid;
      class->max_interface_id = D.24483;
      num_ifaces.138 = (unsigned int) num_ifaces;
      D.24485 = num_ifaces.138 * 4;
      interfaces_full = monoeg_malloc0 (D.24485);
      num_ifaces.138 = (unsigned int) num_ifaces;
      D.24485 = num_ifaces.138 * 4;
      interface_offsets_full = monoeg_malloc (D.24485);
      i = 0;
      goto <D.19320>;
      <D.19319>:
      i.134 = (unsigned int) i;
      D.24441 = i.134 * 4;
      D.24486 = interface_offsets_full + D.24441;
      *D.24486 = -1;
      i = i + 1;
      <D.19320>:
      if (i < num_ifaces) goto <D.19319>; else goto <D.19321>;
      <D.19321>:
      j = 0;
      goto <D.19327>;
      <D.19326>:
      D.24433 = class->supertypes;
      j.133 = (unsigned int) j;
      D.24435 = j.133 * 4;
      D.24436 = D.24433 + D.24435;
      k = *D.24436;
      j.133 = (unsigned int) j;
      D.24435 = j.133 * 4;
      D.24466 = ifaces_array + D.24435;
      ifaces = *D.24466;
      if (ifaces != 0B) goto <D.24487>; else goto <D.24488>;
      <D.24487>:
      i = 0;
      goto <D.19324>;
      <D.19323>:
      {
        int io;

        D.24461 = ifaces->pdata;
        i.134 = (unsigned int) i;
        D.24441 = i.134 * 4;
        D.24462 = D.24461 + D.24441;
        ic = *D.24462;
        io = mono_class_interface_offset (k, ic);
        D.24489 = io < 0;
        D.24490 = (long int) D.24489;
        D.24491 = __builtin_expect (D.24490, 0);
        if (D.24491 != 0) goto <D.24492>; else goto <D.24493>;
        <D.24492>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "class.c", 3372, "io >= 0");
        <D.24493>:
        set_interface_and_offset (num_ifaces, interfaces_full, interface_offsets_full, ic, io, 1);
      }
      i = i + 1;
      <D.19324>:
      i.136 = (unsigned int) i;
      D.24458 = ifaces->len;
      if (i.136 < D.24458) goto <D.19323>; else goto <D.19325>;
      <D.19325>:
      <D.24488>:
      j = j + 1;
      <D.19327>:
      D.24430 = class->idepth;
      D.24467 = (int) D.24430;
      D.24494 = D.24467 + -1;
      if (D.24494 > j) goto <D.19326>; else goto <D.19328>;
      <D.19328>:
      D.24433 = class->supertypes;
      D.24430 = class->idepth;
      D.24495 = (sizetype) D.24430;
      D.24496 = D.24495 + 1073741823;
      D.24497 = D.24496 * 4;
      D.24498 = D.24433 + D.24497;
      D.24499 = *D.24498;
      D.24500 = D.24499 != class;
      D.24501 = (long int) D.24500;
      D.24502 = __builtin_expect (D.24501, 0);
      if (D.24502 != 0) goto <D.24503>; else goto <D.24504>;
      <D.24503>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "class.c", 3378, "class == class->supertypes [class->idepth - 1]");
      <D.24504>:
      D.24430 = class->idepth;
      D.24495 = (sizetype) D.24430;
      D.24496 = D.24495 + 1073741823;
      D.24497 = D.24496 * 4;
      D.24505 = ifaces_array + D.24497;
      ifaces = *D.24505;
      if (ifaces != 0B) goto <D.24506>; else goto <D.24507>;
      <D.24506>:
      i = 0;
      goto <D.19333>;
      <D.19332>:
      {
        int count;

        D.24461 = ifaces->pdata;
        i.134 = (unsigned int) i;
        D.24441 = i.134 * 4;
        D.24462 = D.24461 + D.24441;
        ic = *D.24462;
        D.24508 = set_interface_and_offset (num_ifaces, interfaces_full, interface_offsets_full, ic, cur_slot, 0);
        if (D.24508 != 0) goto <D.24509>; else goto <D.24510>;
        <D.24509>:
        // predicted unlikely by continue predictor.
        goto <D.19330>;
        <D.24510>:
        count = count_virtual_methods (ic);
        if (count == -1) goto <D.24511>; else goto <D.24512>;
        <D.24511>:
        {
          char * name;

          name = mono_type_get_full_name (ic);
          D.24513 = monoeg_g_strdup_printf ("Error calculating interface offset of %s", name);
          mono_class_set_failure (class, 7, D.24513);
          monoeg_g_free (name);
          cur_slot = -1;
          goto end;
        }
        <D.24512>:
        cur_slot = cur_slot + count;
      }
      <D.19330>:
      i = i + 1;
      <D.19333>:
      i.136 = (unsigned int) i;
      D.24458 = ifaces->len;
      if (i.136 < D.24458) goto <D.19332>; else goto <D.19334>;
      <D.19334>:
      <D.24507>:
      D.24474 = class->flags;
      D.24475 = D.24474 & 32;
      if (D.24475 != 0) goto <D.24514>; else goto <D.24516>;
      <D.24516>:
      D.24477 = class->byval_arg.type;
      if (D.24477 == 19) goto <D.24514>; else goto <D.24517>;
      <D.24517>:
      D.24477 = class->byval_arg.type;
      if (D.24477 == 30) goto <D.24514>; else goto <D.24515>;
      <D.24514>:
      set_interface_and_offset (num_ifaces, interfaces_full, interface_offsets_full, class, cur_slot, 1);
      <D.24515>:
      num_array_interfaces.137 = num_array_interfaces;
      if (num_array_interfaces.137 != 0) goto <D.24518>; else goto <D.24519>;
      <D.24518>:
      is_enumerator.139 = is_enumerator;
      if (is_enumerator.139 != 0) goto <D.24521>; else goto <D.24522>;
      <D.24521>:
      {
        int ienumerator_idx;
        int ienumerator_offset;

        ienumerator_idx = find_array_interface (class, "IEnumerator`1");
        D.24523 = class->interfaces;
        ienumerator_idx.140 = (unsigned int) ienumerator_idx;
        D.24525 = ienumerator_idx.140 * 4;
        D.24526 = D.24523 + D.24525;
        D.24527 = *D.24526;
        ienumerator_offset = find_interface_offset (num_ifaces, interfaces_full, interface_offsets_full, D.24527);
        D.24528 = ienumerator_offset < 0;
        D.24529 = (long int) D.24528;
        D.24530 = __builtin_expect (D.24529, 0);
        if (D.24530 != 0) goto <D.24531>; else goto <D.24532>;
        <D.24531>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "class.c", 3405, "ienumerator_offset >= 0");
        <D.24532>:
        i = 0;
        goto <D.19347>;
        <D.19346>:
        i.134 = (unsigned int) i;
        D.24441 = i.134 * 4;
        D.24468 = array_interfaces + D.24441;
        ic = *D.24468;
        {
          size_t __s1_len;
          size_t __s2_len;

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

            __s2 = ic->name;
            D.24536 = "IEnumerator`1";
            D.24537 = MEM[(const unsigned char *)D.24536];
            D.24538 = (int) D.24537;
            D.24539 = *__s2;
            D.24540 = (int) D.24539;
            __result = D.24538 - D.24540;
            {
              D.24541 = __s2_len != 0;
              D.24542 = __result == 0;
              D.24543 = D.24541 & D.24542;
              if (D.24543 != 0) goto <D.24544>; else goto <D.24545>;
              <D.24544>:
              D.24546 = &MEM[(void *)"IEnumerator`1" + 1B];
              D.24547 = *D.24546;
              D.24548 = (int) D.24547;
              D.24549 = __s2 + 1;
              D.24550 = *D.24549;
              D.24551 = (int) D.24550;
              __result = D.24548 - D.24551;
              D.24552 = __s2_len > 1;
              D.24542 = __result == 0;
              D.24553 = D.24552 & D.24542;
              if (D.24553 != 0) goto <D.24554>; else goto <D.24555>;
              <D.24554>:
              D.24556 = &MEM[(void *)"IEnumerator`1" + 2B];
              D.24557 = *D.24556;
              D.24558 = (int) D.24557;
              D.24559 = __s2 + 2;
              D.24560 = *D.24559;
              D.24561 = (int) D.24560;
              __result = D.24558 - D.24561;
              D.24562 = __s2_len > 2;
              D.24542 = __result == 0;
              D.24563 = D.24562 & D.24542;
              if (D.24563 != 0) goto <D.24564>; else goto <D.24565>;
              <D.24564>:
              D.24566 = &MEM[(void *)"IEnumerator`1" + 3B];
              D.24567 = *D.24566;
              D.24568 = (int) D.24567;
              D.24569 = __s2 + 3;
              D.24570 = *D.24569;
              D.24571 = (int) D.24570;
              __result = D.24568 - D.24571;
              <D.24565>:
              <D.24555>:
              <D.24545>:
            }
            D.19344 = __result;
          }
          iftmp.141 = -D.19344;
          goto <D.24572>;
          <D.24535>:
          D.24573 = ic->name;
          iftmp.141 = __builtin_strcmp (D.24573, "IEnumerator`1");
          <D.24572>:
          D.19345 = iftmp.141;
        }
        if (D.19345 == 0) goto <D.24574>; else goto <D.24575>;
        <D.24574>:
        set_interface_and_offset (num_ifaces, interfaces_full, interface_offsets_full, ic, ienumerator_offset, 1);
        goto <D.24576>;
        <D.24575>:
        monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "class.c", 3411);
        <D.24576>:
        i = i + 1;
        <D.19347>:
        num_array_interfaces.137 = num_array_interfaces;
        if (i < num_array_interfaces.137) goto <D.19346>; else goto <D.19348>;
        <D.19348>:
      }
      goto <D.24577>;
      <D.24522>:
      {
        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.24523 = class->interfaces;
        ilist_iface_idx.142 = (unsigned int) ilist_iface_idx;
        D.24579 = ilist_iface_idx.142 * 4;
        D.24580 = D.24523 + D.24579;
        ilist_class = *D.24580;
        ireadonlylist_iface_idx = find_array_interface (class, "IReadOnlyList`1");
        if (ireadonlylist_iface_idx != -1) goto <D.24582>; else goto <D.24583>;
        <D.24582>:
        D.24523 = class->interfaces;
        ireadonlylist_iface_idx.144 = (unsigned int) ireadonlylist_iface_idx;
        D.24585 = ireadonlylist_iface_idx.144 * 4;
        D.24586 = D.24523 + D.24585;
        iftmp.143 = *D.24586;
        goto <D.24587>;
        <D.24583>:
        iftmp.143 = 0B;
        <D.24587>:
        ireadonlylist_class = iftmp.143;
        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.24589>; else goto <D.24590>;
        <D.24589>:
        iftmp.145 = find_array_interface (ireadonlylist_class, "IReadOnlyCollection`1");
        goto <D.24591>;
        <D.24590>:
        iftmp.145 = -1;
        <D.24591>:
        ireadonlycollection_iface_idx = iftmp.145;
        D.24523 = class->interfaces;
        ilist_iface_idx.142 = (unsigned int) ilist_iface_idx;
        D.24579 = ilist_iface_idx.142 * 4;
        D.24580 = D.24523 + D.24579;
        D.24592 = *D.24580;
        ilist_offset = find_interface_offset (num_ifaces, interfaces_full, interface_offsets_full, D.24592);
        D.24593 = ilist_class->interfaces;
        icollection_iface_idx.146 = (unsigned int) icollection_iface_idx;
        D.24595 = icollection_iface_idx.146 * 4;
        D.24596 = D.24593 + D.24595;
        D.24597 = *D.24596;
        icollection_offset = find_interface_offset (num_ifaces, interfaces_full, interface_offsets_full, D.24597);
        D.24593 = ilist_class->interfaces;
        ienumerable_iface_idx.147 = (unsigned int) ienumerable_iface_idx;
        D.24599 = ienumerable_iface_idx.147 * 4;
        D.24600 = D.24593 + D.24599;
        D.24601 = *D.24600;
        ienumerable_offset = find_interface_offset (num_ifaces, interfaces_full, interface_offsets_full, D.24601);
        if (ireadonlylist_iface_idx != -1) goto <D.24603>; else goto <D.24604>;
        <D.24603>:
        D.24523 = class->interfaces;
        ireadonlylist_iface_idx.144 = (unsigned int) ireadonlylist_iface_idx;
        D.24585 = ireadonlylist_iface_idx.144 * 4;
        D.24586 = D.24523 + D.24585;
        D.24605 = *D.24586;
        iftmp.148 = find_interface_offset (num_ifaces, interfaces_full, interface_offsets_full, D.24605);
        goto <D.24606>;
        <D.24604>:
        iftmp.148 = -1;
        <D.24606>:
        ireadonlylist_offset = iftmp.148;
        if (ireadonlycollection_iface_idx != -1) goto <D.24608>; else goto <D.24609>;
        <D.24608>:
        D.24610 = ireadonlylist_class->interfaces;
        ireadonlycollection_iface_idx.150 = (unsigned int) ireadonlycollection_iface_idx;
        D.24612 = ireadonlycollection_iface_idx.150 * 4;
        D.24613 = D.24610 + D.24612;
        D.24614 = *D.24613;
        iftmp.149 = find_interface_offset (num_ifaces, interfaces_full, interface_offsets_full, D.24614);
        goto <D.24615>;
        <D.24609>:
        iftmp.149 = -1;
        <D.24615>:
        ireadonlycollection_offset = iftmp.149;
        D.24620 = ilist_offset < 0;
        D.24621 = icollection_offset < 0;
        D.24622 = D.24620 | D.24621;
        if (D.24622 != 0) goto <D.24617>; else goto <D.24623>;
        <D.24623>:
        if (ienumerable_offset < 0) goto <D.24617>; else goto <D.24618>;
        <D.24617>:
        iftmp.151 = 1;
        goto <D.24619>;
        <D.24618>:
        iftmp.151 = 0;
        <D.24619>:
        D.24624 = iftmp.151 != 0;
        D.24625 = (long int) D.24624;
        D.24626 = __builtin_expect (D.24625, 0);
        if (D.24626 != 0) goto <D.24627>; else goto <D.24628>;
        <D.24627>:
        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.24628>:
        i = 0;
        goto <D.19399>;
        <D.19398>:
        {
          int offset;

          i.134 = (unsigned int) i;
          D.24441 = i.134 * 4;
          D.24468 = array_interfaces + D.24441;
          ic = *D.24468;
          D.24629 = ic->generic_class;
          D.24630 = D.24629->container_class;
          D.24631 = mono_defaults.generic_ilist_class;
          if (D.24630 == D.24631) goto <D.24632>; else goto <D.24633>;
          <D.24632>:
          offset = ilist_offset;
          goto <D.24634>;
          <D.24633>:
          {
            size_t __s1_len;
            size_t __s2_len;

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

              __s2 = ic->name;
              D.24638 = "ICollection`1";
              D.24639 = MEM[(const unsigned char *)D.24638];
              D.24640 = (int) D.24639;
              D.24641 = *__s2;
              D.24642 = (int) D.24641;
              __result = D.24640 - D.24642;
              {
                D.24643 = __s2_len != 0;
                D.24644 = __result == 0;
                D.24645 = D.24643 & D.24644;
                if (D.24645 != 0) goto <D.24646>; else goto <D.24647>;
                <D.24646>:
                D.24648 = &MEM[(void *)"ICollection`1" + 1B];
                D.24649 = *D.24648;
                D.24650 = (int) D.24649;
                D.24651 = __s2 + 1;
                D.24652 = *D.24651;
                D.24653 = (int) D.24652;
                __result = D.24650 - D.24653;
                D.24654 = __s2_len > 1;
                D.24644 = __result == 0;
                D.24655 = D.24654 & D.24644;
                if (D.24655 != 0) goto <D.24656>; else goto <D.24657>;
                <D.24656>:
                D.24658 = &MEM[(void *)"ICollection`1" + 2B];
                D.24659 = *D.24658;
                D.24660 = (int) D.24659;
                D.24661 = __s2 + 2;
                D.24662 = *D.24661;
                D.24663 = (int) D.24662;
                __result = D.24660 - D.24663;
                D.24664 = __s2_len > 2;
                D.24644 = __result == 0;
                D.24665 = D.24664 & D.24644;
                if (D.24665 != 0) goto <D.24666>; else goto <D.24667>;
                <D.24666>:
                D.24668 = &MEM[(void *)"ICollection`1" + 3B];
                D.24669 = *D.24668;
                D.24670 = (int) D.24669;
                D.24671 = __s2 + 3;
                D.24672 = *D.24671;
                D.24673 = (int) D.24672;
                __result = D.24670 - D.24673;
                <D.24667>:
                <D.24657>:
                <D.24647>:
              }
              D.19369 = __result;
            }
            iftmp.152 = -D.19369;
            goto <D.24674>;
            <D.24637>:
            D.24573 = ic->name;
            iftmp.152 = __builtin_strcmp (D.24573, "ICollection`1");
            <D.24674>:
            D.19370 = iftmp.152;
          }
          if (D.19370 == 0) goto <D.24675>; else goto <D.24676>;
          <D.24675>:
          offset = icollection_offset;
          goto <D.24677>;
          <D.24676>:
          {
            size_t __s1_len;
            size_t __s2_len;

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

              __s2 = ic->name;
              D.24681 = "IEnumerable`1";
              D.24682 = MEM[(const unsigned char *)D.24681];
              D.24683 = (int) D.24682;
              D.24684 = *__s2;
              D.24685 = (int) D.24684;
              __result = D.24683 - D.24685;
              {
                D.24686 = __s2_len != 0;
                D.24687 = __result == 0;
                D.24688 = D.24686 & D.24687;
                if (D.24688 != 0) goto <D.24689>; else goto <D.24690>;
                <D.24689>:
                D.24691 = &MEM[(void *)"IEnumerable`1" + 1B];
                D.24692 = *D.24691;
                D.24693 = (int) D.24692;
                D.24694 = __s2 + 1;
                D.24695 = *D.24694;
                D.24696 = (int) D.24695;
                __result = D.24693 - D.24696;
                D.24697 = __s2_len > 1;
                D.24687 = __result == 0;
                D.24698 = D.24697 & D.24687;
                if (D.24698 != 0) goto <D.24699>; else goto <D.24700>;
                <D.24699>:
                D.24701 = &MEM[(void *)"IEnumerable`1" + 2B];
                D.24702 = *D.24701;
                D.24703 = (int) D.24702;
                D.24704 = __s2 + 2;
                D.24705 = *D.24704;
                D.24706 = (int) D.24705;
                __result = D.24703 - D.24706;
                D.24707 = __s2_len > 2;
                D.24687 = __result == 0;
                D.24708 = D.24707 & D.24687;
                if (D.24708 != 0) goto <D.24709>; else goto <D.24710>;
                <D.24709>:
                D.24711 = &MEM[(void *)"IEnumerable`1" + 3B];
                D.24712 = *D.24711;
                D.24713 = (int) D.24712;
                D.24714 = __s2 + 3;
                D.24715 = *D.24714;
                D.24716 = (int) D.24715;
                __result = D.24713 - D.24716;
                <D.24710>:
                <D.24700>:
                <D.24690>:
              }
              D.19378 = __result;
            }
            iftmp.153 = -D.19378;
            goto <D.24717>;
            <D.24680>:
            D.24573 = ic->name;
            iftmp.153 = __builtin_strcmp (D.24573, "IEnumerable`1");
            <D.24717>:
            D.19379 = iftmp.153;
          }
          if (D.19379 == 0) goto <D.24718>; else goto <D.24719>;
          <D.24718>:
          offset = ienumerable_offset;
          goto <D.24720>;
          <D.24719>:
          {
            size_t __s1_len;
            size_t __s2_len;

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

              __s2 = ic->name;
              D.24724 = "IReadOnlyList`1";
              D.24725 = MEM[(const unsigned char *)D.24724];
              D.24726 = (int) D.24725;
              D.24727 = *__s2;
              D.24728 = (int) D.24727;
              __result = D.24726 - D.24728;
              {
                D.24729 = __s2_len != 0;
                D.24730 = __result == 0;
                D.24731 = D.24729 & D.24730;
                if (D.24731 != 0) goto <D.24732>; else goto <D.24733>;
                <D.24732>:
                D.24734 = &MEM[(void *)"IReadOnlyList`1" + 1B];
                D.24735 = *D.24734;
                D.24736 = (int) D.24735;
                D.24737 = __s2 + 1;
                D.24738 = *D.24737;
                D.24739 = (int) D.24738;
                __result = D.24736 - D.24739;
                D.24740 = __s2_len > 1;
                D.24730 = __result == 0;
                D.24741 = D.24740 & D.24730;
                if (D.24741 != 0) goto <D.24742>; else goto <D.24743>;
                <D.24742>:
                D.24744 = &MEM[(void *)"IReadOnlyList`1" + 2B];
                D.24745 = *D.24744;
                D.24746 = (int) D.24745;
                D.24747 = __s2 + 2;
                D.24748 = *D.24747;
                D.24749 = (int) D.24748;
                __result = D.24746 - D.24749;
                D.24750 = __s2_len > 2;
                D.24730 = __result == 0;
                D.24751 = D.24750 & D.24730;
                if (D.24751 != 0) goto <D.24752>; else goto <D.24753>;
                <D.24752>:
                D.24754 = &MEM[(void *)"IReadOnlyList`1" + 3B];
                D.24755 = *D.24754;
                D.24756 = (int) D.24755;
                D.24757 = __s2 + 3;
                D.24758 = *D.24757;
                D.24759 = (int) D.24758;
                __result = D.24756 - D.24759;
                <D.24753>:
                <D.24743>:
                <D.24733>:
              }
              D.19387 = __result;
            }
            iftmp.154 = -D.19387;
            goto <D.24760>;
            <D.24723>:
            D.24573 = ic->name;
            iftmp.154 = __builtin_strcmp (D.24573, "IReadOnlyList`1");
            <D.24760>:
            D.19388 = iftmp.154;
          }
          if (D.19388 == 0) goto <D.24761>; else goto <D.24762>;
          <D.24761>:
          offset = ireadonlylist_offset;
          goto <D.24763>;
          <D.24762>:
          {
            size_t __s1_len;
            size_t __s2_len;

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

              __s2 = ic->name;
              D.24767 = "IReadOnlyCollection`1";
              D.24768 = MEM[(const unsigned char *)D.24767];
              D.24769 = (int) D.24768;
              D.24770 = *__s2;
              D.24771 = (int) D.24770;
              __result = D.24769 - D.24771;
              {
                D.24772 = __s2_len != 0;
                D.24773 = __result == 0;
                D.24774 = D.24772 & D.24773;
                if (D.24774 != 0) goto <D.24775>; else goto <D.24776>;
                <D.24775>:
                D.24777 = &MEM[(void *)"IReadOnlyCollection`1" + 1B];
                D.24778 = *D.24777;
                D.24779 = (int) D.24778;
                D.24780 = __s2 + 1;
                D.24781 = *D.24780;
                D.24782 = (int) D.24781;
                __result = D.24779 - D.24782;
                D.24783 = __s2_len > 1;
                D.24773 = __result == 0;
                D.24784 = D.24783 & D.24773;
                if (D.24784 != 0) goto <D.24785>; else goto <D.24786>;
                <D.24785>:
                D.24787 = &MEM[(void *)"IReadOnlyCollection`1" + 2B];
                D.24788 = *D.24787;
                D.24789 = (int) D.24788;
                D.24790 = __s2 + 2;
                D.24791 = *D.24790;
                D.24792 = (int) D.24791;
                __result = D.24789 - D.24792;
                D.24793 = __s2_len > 2;
                D.24773 = __result == 0;
                D.24794 = D.24793 & D.24773;
                if (D.24794 != 0) goto <D.24795>; else goto <D.24796>;
                <D.24795>:
                D.24797 = &MEM[(void *)"IReadOnlyCollection`1" + 3B];
                D.24798 = *D.24797;
                D.24799 = (int) D.24798;
                D.24800 = __s2 + 3;
                D.24801 = *D.24800;
                D.24802 = (int) D.24801;
                __result = D.24799 - D.24802;
                <D.24796>:
                <D.24786>:
                <D.24776>:
              }
              D.19396 = __result;
            }
            iftmp.155 = -D.19396;
            goto <D.24803>;
            <D.24766>:
            D.24573 = ic->name;
            iftmp.155 = __builtin_strcmp (D.24573, "IReadOnlyCollection`1");
            <D.24803>:
            D.19397 = iftmp.155;
          }
          if (D.19397 == 0) goto <D.24804>; else goto <D.24805>;
          <D.24804>:
          offset = ireadonlycollection_offset;
          goto <D.24806>;
          <D.24805>:
          monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "class.c", 3443);
          <D.24806>:
          <D.24763>:
          <D.24720>:
          <D.24677>:
          <D.24634>:
          set_interface_and_offset (num_ifaces, interfaces_full, interface_offsets_full, ic, offset, 1);
        }
        i = i + 1;
        <D.19399>:
        num_array_interfaces.137 = num_array_interfaces;
        if (i < num_array_interfaces.137) goto <D.19398>; else goto <D.19400>;
        <D.19400>:
      }
      <D.24577>:
      <D.24519>:
      interface_offsets_count = 0;
      i = 0;
      goto <D.19402>;
      <D.19401>:
      i.134 = (unsigned int) i;
      D.24441 = i.134 * 4;
      D.24486 = interface_offsets_full + D.24441;
      D.24807 = *D.24486;
      if (D.24807 != -1) goto <D.24808>; else goto <D.24809>;
      <D.24808>:
      interface_offsets_count = interface_offsets_count + 1;
      <D.24809>:
      i = i + 1;
      <D.19402>:
      if (i < num_ifaces) goto <D.19401>; else goto <D.19403>;
      <D.19403>:
      D.24812 = class->interfaces_packed;
      if (D.24812 != 0B) goto <D.24813>; else goto <D.24810>;
      <D.24813>:
      if (overwrite == 0) goto <D.24814>; else goto <D.24810>;
      <D.24814>:
      D.24815 = class->interface_offsets_count;
      D.24816 = (int) D.24815;
      D.24817 = D.24816 != interface_offsets_count;
      D.24818 = (long int) D.24817;
      D.24819 = __builtin_expect (D.24818, 0);
      if (D.24819 != 0) goto <D.24820>; else goto <D.24821>;
      <D.24820>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "class.c", 3465, "class->interface_offsets_count == interface_offsets_count");
      <D.24821>:
      goto <D.24811>;
      <D.24810>:
      {
        uint8_t * bitmap;
        int bsize;

        D.24822 = (short unsigned int) interface_offsets_count;
        class->interface_offsets_count = D.24822;
        interface_offsets_count.156 = (unsigned int) interface_offsets_count;
        D.24824 = interface_offsets_count.156 * 4;
        D.24825 = (int) D.24824;
        D.24826 = mono_class_alloc (class, D.24825);
        class->interfaces_packed = D.24826;
        interface_offsets_count.156 = (unsigned int) interface_offsets_count;
        D.24827 = interface_offsets_count.156 * 2;
        D.24828 = (int) D.24827;
        D.24829 = mono_class_alloc (class, D.24828);
        class->interface_offsets_packed = D.24829;
        D.24830 = max_iid + 1;
        D.24831 = D.24830 >> 3;
        D.24832 = (unsigned int) D.24831;
        D.24830 = max_iid + 1;
        D.24834 = D.24830 & 7;
        if (D.24834 != 0) goto <D.24835>; else goto <D.24836>;
        <D.24835>:
        iftmp.157 = 1;
        goto <D.24837>;
        <D.24836>:
        iftmp.157 = 0;
        <D.24837>:
        D.24838 = D.24832 + iftmp.157;
        bsize = (int) D.24838;
        bitmap = mono_class_alloc0 (class, bsize);
        i = 0;
        goto <D.19408>;
        <D.19407>:
        {
          int id;

          i.134 = (unsigned int) i;
          D.24441 = i.134 * 4;
          D.24839 = interfaces_full + D.24441;
          D.24840 = *D.24839;
          D.24841 = D.24840->interface_id;
          id = (int) D.24841;
          D.24842 = id >> 3;
          D.24843 = (sizetype) D.24842;
          D.24844 = bitmap + D.24843;
          D.24842 = id >> 3;
          D.24843 = (sizetype) D.24842;
          D.24844 = bitmap + D.24843;
          D.24845 = *D.24844;
          D.24846 = (signed char) D.24845;
          D.24847 = id & 7;
          D.24848 = 1 << D.24847;
          D.24849 = (signed char) D.24848;
          D.24850 = D.24846 | D.24849;
          D.24851 = (unsigned char) D.24850;
          *D.24844 = D.24851;
          D.24812 = class->interfaces_packed;
          i.134 = (unsigned int) i;
          D.24441 = i.134 * 4;
          D.24852 = D.24812 + D.24441;
          i.134 = (unsigned int) i;
          D.24441 = i.134 * 4;
          D.24839 = interfaces_full + D.24441;
          D.24840 = *D.24839;
          *D.24852 = D.24840;
          D.24853 = class->interface_offsets_packed;
          i.134 = (unsigned int) i;
          D.24854 = i.134 * 2;
          D.24855 = D.24853 + D.24854;
          i.134 = (unsigned int) i;
          D.24441 = i.134 * 4;
          D.24486 = interface_offsets_full + D.24441;
          D.24807 = *D.24486;
          D.24856 = (short unsigned int) D.24807;
          *D.24855 = D.24856;
        }
        i = i + 1;
        <D.19408>:
        if (i < interface_offsets_count) goto <D.19407>; else goto <D.19409>;
        <D.19409>:
        class->interface_bitmap = bitmap;
      }
      <D.24811>:
      end:
      monoeg_g_free (interfaces_full);
      monoeg_g_free (interface_offsets_full);
      monoeg_g_free (array_interfaces);
      i = 0;
      goto <D.19411>;
      <D.19410>:
      i.134 = (unsigned int) i;
      D.24441 = i.134 * 4;
      D.24857 = ifaces_array + D.24441;
      ifaces = *D.24857;
      if (ifaces != 0B) goto <D.24858>; else goto <D.24859>;
      <D.24858>:
      monoeg_g_ptr_array_free (ifaces, 1);
      <D.24859>:
      i = i + 1;
      <D.19411>:
      D.24430 = class->idepth;
      D.24467 = (int) D.24430;
      if (D.24467 > i) goto <D.19410>; else goto <D.19412>;
      <D.19412>:
      monoeg_g_free (ifaces_array);
      D.24860 = cur_slot;
      return D.24860;
    }
  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.24863;
  struct MonoClass * * D.24866;
  unsigned char D.24867;
  unsigned char D.24868;
  struct MonoGenericClass * D.24873;
  struct MonoClass * D.24875;
  struct MonoClass * D.24876;
  int D.19198;
  int iftmp.158;
  int D.19197;
  const char[21] * D.24881;
  unsigned char D.24882;
  int D.24883;
  unsigned char D.24884;
  int D.24885;
  _Bool D.24886;
  _Bool D.24887;
  _Bool D.24888;
  const unsigned char * D.24891;
  unsigned char D.24892;
  int D.24893;
  const unsigned char * D.24894;
  unsigned char D.24895;
  int D.24896;
  _Bool D.24897;
  _Bool D.24898;
  const unsigned char * D.24901;
  unsigned char D.24902;
  int D.24903;
  const unsigned char * D.24904;
  unsigned char D.24905;
  int D.24906;
  _Bool D.24907;
  _Bool D.24908;
  const unsigned char * D.24911;
  unsigned char D.24912;
  int D.24913;
  const unsigned char * D.24914;
  unsigned char D.24915;
  int D.24916;
  const char * D.24918;
  struct MonoGenericInst * D.24920;
  struct MonoType * D.24921;
  int iftmp.159;
  struct MonoClass * D.24929;
  unsigned char D.24930;
  struct MonoClass * generic_icollection_class.160;
  struct MonoImage * D.24934;
  struct MonoClass * generic_icollection_class.161;
  struct MonoClass * generic_ienumerable_class.162;
  struct MonoClass * generic_ienumerator_class.163;
  struct MonoClass * generic_ireadonlylist_class.164;
  struct MonoClass * generic_ireadonlycollection_class.165;
  unsigned char D.24940;
  unsigned char D.24941;
  int iftmp.166;
  struct MonoClass * generic_ireadonlylist_class.167;
  int iftmp.168;
  struct MonoClass * D.24950;
  unsigned int real_count.169;
  unsigned int D.24959;
  struct MonoClass * D.24960;
  unsigned int nifaces.170;
  unsigned int D.24964;
  struct MonoClass * * D.24965;
  short unsigned int D.24967;
  int iftmp.171;
  unsigned char D.24976;
  _Bool D.24977;
  _Bool D.24978;
  _Bool D.24979;
  struct MonoImage * D.24982;
  unsigned char D.24983;
  unsigned char D.24984;
  unsigned char D.24986;
  int iftmp.172;
  short unsigned int D.24990;
  short unsigned int D.24992;
  unsigned int D.24996;
  unsigned int D.24997;
  unsigned char D.24999;
  unsigned char D.25003;
  unsigned char D.25004;
  int iftmp.173;
  int D.25017;
  int D.25018;
  struct MonoClass * D.25025;
  struct MonoClass * * D.25026;
  unsigned int i.174;
  unsigned int D.25028;
  struct MonoClass * * D.25029;
  struct MonoClass * D.25030;
  unsigned int j.175;
  unsigned int D.25032;
  struct MonoClass * * D.25033;
  struct MonoClass * * D.25036;
  struct MonoClass * * D.25037;
  struct MonoClass * D.25038;
  struct MonoClass * * D.25040;
  struct MonoClass * * D.25041;
  struct MonoClass * D.25042;
  int D.25043;
  unsigned int original_rank.176;
  struct MonoClass * D.25047;
  struct MonoClass * * D.25048;
  struct MonoClass * D.25049;
  sizetype i.177;
  sizetype D.25051;
  sizetype D.25052;
  struct MonoClass * * D.25053;
  struct MonoClass * D.25054;
  sizetype D.25057;
  sizetype D.25058;
  struct MonoClass * * D.25059;
  struct MonoClass * generic_ienumerable_class.178;
  struct MonoClass * D.25061;
  sizetype D.25064;
  sizetype D.25065;
  struct MonoClass * * D.25066;
  struct MonoClass * D.25067;
  sizetype D.25068;
  sizetype D.25069;
  struct MonoClass * * D.25070;
  struct MonoClass * generic_ireadonlycollection_class.179;
  struct MonoClass * D.25072;
  struct MonoClass * D.25076;
  struct MonoClass * D.25079;
  struct MonoClass * generic_ienumerator_class.180;
  struct MonoClass * D.25081;
  unsigned int j.181;
  unsigned int D.25089;
  struct MonoClass * * D.25090;
  struct MonoClass * D.25091;
  struct MonoClass * D.25092;
  int D.25093;
  struct MonoClass * D.25094;
  int j.182;
  unsigned int j.183;
  unsigned int D.25098;
  struct MonoClass * * D.25099;
  struct MonoClass * D.25100;
  struct MonoClass * D.25101;
  struct MonoClass * D.25104;
  struct MonoClass * D.25105;
  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.24863 = mono_defaults.generic_ilist_class;
      if (D.24863 == 0B) goto <D.24864>; else goto <D.24865>;
      <D.24864>:
      *num = 0;
      D.24866 = 0B;
      return D.24866;
      <D.24865>:
      internal_enumerator = 0;
      eclass_is_valuetype = 0;
      D.24867 = eclass->rank;
      original_rank = (int) D.24867;
      D.24868 = class->byval_arg.type;
      if (D.24868 != 29) goto <D.24869>; else goto <D.24870>;
      <D.24869>:
      D.24873 = class->generic_class;
      if (D.24873 != 0B) goto <D.24874>; else goto <D.24871>;
      <D.24874>:
      D.24875 = class->nested_in;
      D.24876 = mono_defaults.array_class;
      if (D.24875 == D.24876) goto <D.24877>; else goto <D.24871>;
      <D.24877>:
      {
        size_t __s1_len;
        size_t __s2_len;

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

          __s2 = class->name;
          D.24881 = "InternalEnumerator`1";
          D.24882 = MEM[(const unsigned char *)D.24881];
          D.24883 = (int) D.24882;
          D.24884 = *__s2;
          D.24885 = (int) D.24884;
          __result = D.24883 - D.24885;
          {
            D.24886 = __s2_len != 0;
            D.24887 = __result == 0;
            D.24888 = D.24886 & D.24887;
            if (D.24888 != 0) goto <D.24889>; else goto <D.24890>;
            <D.24889>:
            D.24891 = &MEM[(void *)"InternalEnumerator`1" + 1B];
            D.24892 = *D.24891;
            D.24893 = (int) D.24892;
            D.24894 = __s2 + 1;
            D.24895 = *D.24894;
            D.24896 = (int) D.24895;
            __result = D.24893 - D.24896;
            D.24897 = __s2_len > 1;
            D.24887 = __result == 0;
            D.24898 = D.24897 & D.24887;
            if (D.24898 != 0) goto <D.24899>; else goto <D.24900>;
            <D.24899>:
            D.24901 = &MEM[(void *)"InternalEnumerator`1" + 2B];
            D.24902 = *D.24901;
            D.24903 = (int) D.24902;
            D.24904 = __s2 + 2;
            D.24905 = *D.24904;
            D.24906 = (int) D.24905;
            __result = D.24903 - D.24906;
            D.24907 = __s2_len > 2;
            D.24887 = __result == 0;
            D.24908 = D.24907 & D.24887;
            if (D.24908 != 0) goto <D.24909>; else goto <D.24910>;
            <D.24909>:
            D.24911 = &MEM[(void *)"InternalEnumerator`1" + 3B];
            D.24912 = *D.24911;
            D.24913 = (int) D.24912;
            D.24914 = __s2 + 3;
            D.24915 = *D.24914;
            D.24916 = (int) D.24915;
            __result = D.24913 - D.24916;
            <D.24910>:
            <D.24900>:
            <D.24890>:
          }
          D.19197 = __result;
        }
        iftmp.158 = -D.19197;
        goto <D.24917>;
        <D.24880>:
        D.24918 = class->name;
        iftmp.158 = __builtin_strcmp (D.24918, "InternalEnumerator`1");
        <D.24917>:
        D.19198 = iftmp.158;
      }
      if (D.19198 == 0) goto <D.24919>; else goto <D.24871>;
      <D.24919>:
      D.24873 = class->generic_class;
      D.24920 = D.24873->context.class_inst;
      D.24921 = D.24920->type_argv[0];
      eclass = mono_class_from_mono_type (D.24921);
      D.24867 = eclass->rank;
      original_rank = (int) D.24867;
      D.24867 = eclass->rank;
      if (D.24867 == 0) goto <D.24922>; else goto <D.24923>;
      <D.24922>:
      eclass = eclass->element_class;
      <D.24923>:
      internal_enumerator = 1;
      *is_enumerator = 1;
      goto <D.24872>;
      <D.24871>:
      *num = 0;
      D.24866 = 0B;
      return D.24866;
      <D.24872>:
      <D.24870>:
      D.24867 = eclass->rank;
      if (D.24867 == 0) goto <D.24925>; else goto <D.24928>;
      <D.24928>:
      D.24929 = eclass->element_class;
      D.24930 = D.24929->rank;
      if (D.24930 == 0) goto <D.24925>; else goto <D.24926>;
      <D.24925>:
      iftmp.159 = 1;
      goto <D.24927>;
      <D.24926>:
      iftmp.159 = 0;
      <D.24927>:
      all_interfaces = iftmp.159;
      generic_icollection_class.160 = generic_icollection_class;
      if (generic_icollection_class.160 == 0B) goto <D.24932>; else goto <D.24933>;
      <D.24932>:
      D.24934 = mono_defaults.corlib;
      generic_icollection_class.161 = mono_class_from_name (D.24934, "System.Collections.Generic", "ICollection`1");
      generic_icollection_class = generic_icollection_class.161;
      D.24934 = mono_defaults.corlib;
      generic_ienumerable_class.162 = mono_class_from_name (D.24934, "System.Collections.Generic", "IEnumerable`1");
      generic_ienumerable_class = generic_ienumerable_class.162;
      D.24934 = mono_defaults.corlib;
      generic_ienumerator_class.163 = mono_class_from_name (D.24934, "System.Collections.Generic", "IEnumerator`1");
      generic_ienumerator_class = generic_ienumerator_class.163;
      D.24934 = mono_defaults.corlib;
      generic_ireadonlylist_class.164 = mono_class_from_name (D.24934, "System.Collections.Generic", "IReadOnlyList`1");
      generic_ireadonlylist_class = generic_ireadonlylist_class.164;
      D.24934 = mono_defaults.corlib;
      generic_ireadonlycollection_class.165 = mono_class_from_name (D.24934, "System.Collections.Generic", "IReadOnlyCollection`1");
      generic_ireadonlycollection_class = generic_ireadonlycollection_class.165;
      <D.24933>:
      mono_class_init (eclass);
      D.24940 = BIT_FIELD_REF <*eclass, 8, 160>;
      D.24941 = D.24940 & 8;
      if (D.24941 != 0) goto <D.24942>; else goto <D.24943>;
      <D.24942>:
      generic_ireadonlylist_class.167 = generic_ireadonlylist_class;
      if (generic_ireadonlylist_class.167 != 0B) goto <D.24946>; else goto <D.24947>;
      <D.24946>:
      iftmp.166 = 5;
      goto <D.24948>;
      <D.24947>:
      iftmp.166 = 3;
      <D.24948>:
      nifaces = iftmp.166;
      fill_valuetype_array_derived_types (&valuetype_types, eclass, original_rank);
      D.24950 = valuetype_types[1];
      if (D.24950 != 0B) goto <D.24951>; else goto <D.24952>;
      <D.24951>:
      iftmp.168 = nifaces * 2;
      goto <D.24953>;
      <D.24952>:
      iftmp.168 = nifaces;
      <D.24953>:
      interface_count = iftmp.168;
      real_count = interface_count;
      if (internal_enumerator != 0) goto <D.24954>; else goto <D.24955>;
      <D.24954>:
      real_count = real_count + 1;
      D.24950 = valuetype_types[1];
      if (D.24950 != 0B) goto <D.24956>; else goto <D.24957>;
      <D.24956>:
      real_count = real_count + 1;
      <D.24957>:
      <D.24955>:
      real_count.169 = (unsigned int) real_count;
      D.24959 = real_count.169 * 4;
      interfaces = monoeg_malloc0 (D.24959);
      D.24960 = valuetype_types[0];
      *interfaces = D.24960;
      D.24950 = valuetype_types[1];
      if (D.24950 != 0B) goto <D.24961>; else goto <D.24962>;
      <D.24961>:
      nifaces.170 = (unsigned int) nifaces;
      D.24964 = nifaces.170 * 4;
      D.24965 = interfaces + D.24964;
      D.24950 = valuetype_types[1];
      *D.24965 = D.24950;
      <D.24962>:
      eclass_is_valuetype = 1;
      goto <D.24966>;
      <D.24943>:
      {
        int j;
        int idepth;

        D.24967 = eclass->idepth;
        idepth = (int) D.24967;
        if (internal_enumerator == 0) goto <D.24968>; else goto <D.24969>;
        <D.24968>:
        idepth = idepth + -1;
        <D.24969>:
        generic_ireadonlylist_class.167 = generic_ireadonlylist_class;
        if (generic_ireadonlylist_class.167 != 0B) goto <D.24971>; else goto <D.24972>;
        <D.24971>:
        iftmp.171 = 2;
        goto <D.24973>;
        <D.24972>:
        iftmp.171 = 3;
        <D.24973>:
        nifaces = iftmp.171;
        D.24976 = eclass->this_arg.type;
        D.24977 = D.24976 != 19;
        D.24978 = D.24976 != 30;
        D.24979 = D.24977 & D.24978;
        if (D.24979 != 0) goto <D.24980>; else goto <D.24981>;
        <D.24980>:
        D.24982 = eclass->image;
        D.24983 = BIT_FIELD_REF <*D.24982, 8, 128>;
        D.24984 = D.24983 & 8;
        if (D.24984 == 0) goto <D.24974>; else goto <D.24985>;
        <D.24985>:
        D.24940 = BIT_FIELD_REF <*eclass, 8, 160>;
        D.24986 = D.24940 & 128;
        if (D.24986 != 0) goto <D.24974>; else goto <D.24975>;
        <D.24974>:
        mono_class_setup_interface_offsets (eclass);
        <D.24975>:
        <D.24981>:
        if (all_interfaces != 0) goto <D.24988>; else goto <D.24989>;
        <D.24988>:
        D.24990 = eclass->interface_offsets_count;
        iftmp.172 = (int) D.24990;
        goto <D.24991>;
        <D.24989>:
        D.24992 = eclass->interface_count;
        iftmp.172 = (int) D.24992;
        <D.24991>:
        interface_count = iftmp.172;
        D.24996 = eclass->flags;
        D.24997 = D.24996 & 32;
        if (D.24997 != 0) goto <D.24993>; else goto <D.24998>;
        <D.24998>:
        D.24999 = eclass->byval_arg.type;
        if (D.24999 == 19) goto <D.24993>; else goto <D.25000>;
        <D.25000>:
        D.24999 = eclass->byval_arg.type;
        if (D.24999 == 30) goto <D.24993>; else goto <D.24994>;
        <D.24993>:
        interface_count = interface_count + 1;
        goto <D.24995>;
        <D.24994>:
        interface_count = interface_count + idepth;
        <D.24995>:
        D.24867 = eclass->rank;
        if (D.24867 != 0) goto <D.25001>; else goto <D.25002>;
        <D.25001>:
        D.24929 = eclass->element_class;
        D.25003 = BIT_FIELD_REF <*D.24929, 8, 160>;
        D.25004 = D.25003 & 8;
        if (D.25004 != 0) goto <D.25005>; else goto <D.25006>;
        <D.25005>:
        D.24929 = eclass->element_class;
        fill_valuetype_array_derived_types (&valuetype_types, D.24929, original_rank);
        D.24950 = valuetype_types[1];
        if (D.24950 != 0B) goto <D.25007>; else goto <D.25008>;
        <D.25007>:
        interface_count = interface_count + 1;
        <D.25008>:
        <D.25006>:
        <D.25002>:
        interface_count = interface_count * nifaces;
        real_count = interface_count;
        if (internal_enumerator != 0) goto <D.25009>; else goto <D.25010>;
        <D.25009>:
        D.24996 = eclass->flags;
        D.24997 = D.24996 & 32;
        if (D.24997 == 0) goto <D.25014>; else goto <D.25012>;
        <D.25014>:
        D.24999 = eclass->byval_arg.type;
        if (D.24999 != 19) goto <D.25015>; else goto <D.25012>;
        <D.25015>:
        D.24999 = eclass->byval_arg.type;
        if (D.24999 != 30) goto <D.25016>; else goto <D.25012>;
        <D.25016>:
        iftmp.173 = idepth;
        goto <D.25013>;
        <D.25012>:
        iftmp.173 = 1;
        <D.25013>:
        D.24990 = eclass->interface_offsets_count;
        D.25017 = (int) D.24990;
        D.25018 = iftmp.173 + D.25017;
        real_count = D.25018 + real_count;
        D.24950 = valuetype_types[1];
        if (D.24950 != 0B) goto <D.25019>; else goto <D.25020>;
        <D.25019>:
        real_count = real_count + 1;
        <D.25020>:
        <D.25010>:
        real_count.169 = (unsigned int) real_count;
        D.24959 = real_count.169 * 4;
        interfaces = monoeg_malloc0 (D.24959);
        D.24996 = eclass->flags;
        D.24997 = D.24996 & 32;
        if (D.24997 != 0) goto <D.25021>; else goto <D.25023>;
        <D.25023>:
        D.24999 = eclass->byval_arg.type;
        if (D.24999 == 19) goto <D.25021>; else goto <D.25024>;
        <D.25024>:
        D.24999 = eclass->byval_arg.type;
        if (D.24999 == 30) goto <D.25021>; else goto <D.25022>;
        <D.25021>:
        D.25025 = mono_defaults.object_class;
        *interfaces = D.25025;
        j = nifaces;
        goto <D.19203>;
        <D.25022>:
        j = 0;
        i = 0;
        goto <D.19202>;
        <D.19201>:
        D.25026 = eclass->supertypes;
        i.174 = (unsigned int) i;
        D.25028 = i.174 * 4;
        D.25029 = D.25026 + D.25028;
        D.25030 = *D.25029;
        mono_class_init (D.25030);
        j.175 = (unsigned int) j;
        D.25032 = j.175 * 4;
        D.25033 = interfaces + D.25032;
        D.25026 = eclass->supertypes;
        i.174 = (unsigned int) i;
        D.25028 = i.174 * 4;
        D.25029 = D.25026 + D.25028;
        D.25030 = *D.25029;
        *D.25033 = D.25030;
        j = j + nifaces;
        i = i + 1;
        <D.19202>:
        if (i < idepth) goto <D.19201>; else goto <D.19203>;
        <D.19203>:
        if (all_interfaces != 0) goto <D.25034>; else goto <D.25035>;
        <D.25034>:
        i = 0;
        goto <D.19205>;
        <D.19204>:
        j.175 = (unsigned int) j;
        D.25032 = j.175 * 4;
        D.25033 = interfaces + D.25032;
        D.25036 = eclass->interfaces_packed;
        i.174 = (unsigned int) i;
        D.25028 = i.174 * 4;
        D.25037 = D.25036 + D.25028;
        D.25038 = *D.25037;
        *D.25033 = D.25038;
        j = j + nifaces;
        i = i + 1;
        <D.19205>:
        D.24990 = eclass->interface_offsets_count;
        D.25017 = (int) D.24990;
        if (D.25017 > i) goto <D.19204>; else goto <D.19206>;
        <D.19206>:
        goto <D.25039>;
        <D.25035>:
        i = 0;
        goto <D.19208>;
        <D.19207>:
        j.175 = (unsigned int) j;
        D.25032 = j.175 * 4;
        D.25033 = interfaces + D.25032;
        D.25040 = eclass->interfaces;
        i.174 = (unsigned int) i;
        D.25028 = i.174 * 4;
        D.25041 = D.25040 + D.25028;
        D.25042 = *D.25041;
        *D.25033 = D.25042;
        j = j + nifaces;
        i = i + 1;
        <D.19208>:
        D.24992 = eclass->interface_count;
        D.25043 = (int) D.24992;
        if (D.25043 > i) goto <D.19207>; else goto <D.19209>;
        <D.19209>:
        <D.25039>:
        D.24950 = valuetype_types[1];
        if (D.24950 != 0B) goto <D.25044>; else goto <D.25045>;
        <D.25044>:
        j.175 = (unsigned int) j;
        D.25032 = j.175 * 4;
        D.25033 = interfaces + D.25032;
        original_rank.176 = (unsigned int) original_rank;
        D.24950 = valuetype_types[1];
        D.25047 = array_class_get_if_rank (D.24950, original_rank.176);
        *D.25033 = D.25047;
        j = j + nifaces;
        <D.25045>:
      }
      <D.24966>:
      i = 0;
      goto <D.19212>;
      <D.19211>:
      {
        struct MonoClass * iface;

        i.174 = (unsigned int) i;
        D.25028 = i.174 * 4;
        D.25048 = interfaces + D.25028;
        iface = *D.25048;
        i.174 = (unsigned int) i;
        D.25028 = i.174 * 4;
        D.25048 = interfaces + D.25028;
        D.24863 = mono_defaults.generic_ilist_class;
        D.25049 = inflate_class_one_arg (D.24863, iface);
        *D.25048 = D.25049;
        i.177 = (sizetype) i;
        D.25051 = i.177 + 1;
        D.25052 = D.25051 * 4;
        D.25053 = interfaces + D.25052;
        generic_icollection_class.160 = generic_icollection_class;
        D.25054 = inflate_class_one_arg (generic_icollection_class.160, iface);
        *D.25053 = D.25054;
        D.24940 = BIT_FIELD_REF <*eclass, 8, 160>;
        D.24941 = D.24940 & 8;
        if (D.24941 != 0) goto <D.25055>; else goto <D.25056>;
        <D.25055>:
        i.177 = (sizetype) i;
        D.25057 = i.177 + 2;
        D.25058 = D.25057 * 4;
        D.25059 = interfaces + D.25058;
        generic_ienumerable_class.178 = generic_ienumerable_class;
        D.25061 = inflate_class_one_arg (generic_ienumerable_class.178, iface);
        *D.25059 = D.25061;
        generic_ireadonlylist_class.167 = generic_ireadonlylist_class;
        if (generic_ireadonlylist_class.167 != 0B) goto <D.25062>; else goto <D.25063>;
        <D.25062>:
        i.177 = (sizetype) i;
        D.25064 = i.177 + 3;
        D.25065 = D.25064 * 4;
        D.25066 = interfaces + D.25065;
        generic_ireadonlylist_class.167 = generic_ireadonlylist_class;
        D.25067 = inflate_class_one_arg (generic_ireadonlylist_class.167, iface);
        *D.25066 = D.25067;
        i.177 = (sizetype) i;
        D.25068 = i.177 + 4;
        D.25069 = D.25068 * 4;
        D.25070 = interfaces + D.25069;
        generic_ireadonlycollection_class.179 = generic_ireadonlycollection_class;
        D.25072 = inflate_class_one_arg (generic_ireadonlycollection_class.179, iface);
        *D.25070 = D.25072;
        <D.25063>:
        goto <D.25073>;
        <D.25056>:
        generic_ireadonlylist_class.167 = generic_ireadonlylist_class;
        if (generic_ireadonlylist_class.167 == 0B) goto <D.25074>; else goto <D.25075>;
        <D.25074>:
        i.177 = (sizetype) i;
        D.25057 = i.177 + 2;
        D.25058 = D.25057 * 4;
        D.25059 = interfaces + D.25058;
        generic_ienumerable_class.178 = generic_ienumerable_class;
        D.25076 = inflate_class_one_arg (generic_ienumerable_class.178, iface);
        *D.25059 = D.25076;
        <D.25075>:
        <D.25073>:
      }
      i = i + nifaces;
      <D.19212>:
      if (i < interface_count) goto <D.19211>; else goto <D.19213>;
      <D.19213>:
      if (internal_enumerator != 0) goto <D.25077>; else goto <D.25078>;
      <D.25077>:
      {
        int j;

        i = 0;
        goto <D.19216>;
        <D.19215>:
        i.174 = (unsigned int) i;
        D.25028 = i.174 * 4;
        D.25048 = interfaces + D.25028;
        i.174 = (unsigned int) i;
        D.25028 = i.174 * 4;
        D.25048 = interfaces + D.25028;
        D.25079 = *D.25048;
        generic_ienumerator_class.180 = generic_ienumerator_class;
        D.25081 = inflate_class_one_arg (generic_ienumerator_class.180, D.25079);
        *D.25048 = D.25081;
        i = i + 1;
        <D.19216>:
        if (i < interface_count) goto <D.19215>; else goto <D.19217>;
        <D.19217>:
        j = interface_count;
        if (eclass_is_valuetype == 0) goto <D.25082>; else goto <D.25083>;
        <D.25082>:
        D.24996 = eclass->flags;
        D.24997 = D.24996 & 32;
        if (D.24997 != 0) goto <D.25084>; else goto <D.25086>;
        <D.25086>:
        D.24999 = eclass->byval_arg.type;
        if (D.24999 == 19) goto <D.25084>; else goto <D.25087>;
        <D.25087>:
        D.24999 = eclass->byval_arg.type;
        if (D.24999 == 30) goto <D.25084>; else goto <D.25085>;
        <D.25084>:
        j.181 = (unsigned int) j;
        D.25089 = j.181 * 4;
        D.25090 = interfaces + D.25089;
        D.25025 = mono_defaults.object_class;
        generic_ienumerator_class.180 = generic_ienumerator_class;
        D.25091 = inflate_class_one_arg (generic_ienumerator_class.180, D.25025);
        *D.25090 = D.25091;
        j = j + 1;
        goto <D.19220>;
        <D.25085>:
        i = 0;
        goto <D.19219>;
        <D.19218>:
        j.181 = (unsigned int) j;
        D.25089 = j.181 * 4;
        D.25090 = interfaces + D.25089;
        D.25026 = eclass->supertypes;
        i.174 = (unsigned int) i;
        D.25028 = i.174 * 4;
        D.25029 = D.25026 + D.25028;
        D.25030 = *D.25029;
        generic_ienumerator_class.180 = generic_ienumerator_class;
        D.25092 = inflate_class_one_arg (generic_ienumerator_class.180, D.25030);
        *D.25090 = D.25092;
        j = j + 1;
        i = i + 1;
        <D.19219>:
        D.24967 = eclass->idepth;
        D.25093 = (int) D.24967;
        if (D.25093 > i) goto <D.19218>; else goto <D.19220>;
        <D.19220>:
        i = 0;
        goto <D.19222>;
        <D.19221>:
        j.181 = (unsigned int) j;
        D.25089 = j.181 * 4;
        D.25090 = interfaces + D.25089;
        D.25036 = eclass->interfaces_packed;
        i.174 = (unsigned int) i;
        D.25028 = i.174 * 4;
        D.25037 = D.25036 + D.25028;
        D.25038 = *D.25037;
        generic_ienumerator_class.180 = generic_ienumerator_class;
        D.25094 = inflate_class_one_arg (generic_ienumerator_class.180, D.25038);
        *D.25090 = D.25094;
        j = j + 1;
        i = i + 1;
        <D.19222>:
        D.24990 = eclass->interface_offsets_count;
        D.25017 = (int) D.24990;
        if (D.25017 > i) goto <D.19221>; else goto <D.19223>;
        <D.19223>:
        goto <D.25095>;
        <D.25083>:
        j.182 = j;
        j = j.182 + 1;
        j.183 = (unsigned int) j.182;
        D.25098 = j.183 * 4;
        D.25099 = interfaces + D.25098;
        original_rank.176 = (unsigned int) original_rank;
        D.24960 = valuetype_types[0];
        D.25100 = array_class_get_if_rank (D.24960, original_rank.176);
        generic_ienumerator_class.180 = generic_ienumerator_class;
        D.25101 = inflate_class_one_arg (generic_ienumerator_class.180, D.25100);
        *D.25099 = D.25101;
        <D.25095>:
        D.24950 = valuetype_types[1];
        if (D.24950 != 0B) goto <D.25102>; else goto <D.25103>;
        <D.25102>:
        j.181 = (unsigned int) j;
        D.25089 = j.181 * 4;
        D.25090 = interfaces + D.25089;
        original_rank.176 = (unsigned int) original_rank;
        D.24950 = valuetype_types[1];
        D.25104 = array_class_get_if_rank (D.24950, original_rank.176);
        generic_ienumerator_class.180 = generic_ienumerator_class;
        D.25105 = inflate_class_one_arg (generic_ienumerator_class.180, D.25104);
        *D.25090 = D.25105;
        <D.25103>:
      }
      <D.25078>:
      *num = real_count;
      D.24866 = interfaces;
      return D.24866;
    }
  finally
    {
      valuetype_types = {CLOBBER};
    }
}


fill_valuetype_array_derived_types (struct MonoClass * * valuetype_types, struct MonoClass * eclass, int rank)
{
  struct MonoClass * D.25108;
  struct MonoClass * * D.25111;
  struct MonoClass * D.25112;
  struct MonoClass * D.25117;
  struct MonoClass * D.25120;
  struct MonoClass * D.25125;
  struct MonoClass * D.25128;
  struct MonoClass * D.25133;
  struct MonoClass * D.25136;
  unsigned char D.25141;
  unsigned char D.25142;
  struct MonoType * D.25145;
  struct MonoType * D.25148;
  struct MonoClass * D.25149;

  *valuetype_types = eclass;
  D.25108 = mono_defaults.int16_class;
  if (D.25108 == eclass) goto <D.25109>; else goto <D.25110>;
  <D.25109>:
  D.25111 = valuetype_types + 4;
  D.25112 = mono_defaults.uint16_class;
  *D.25111 = D.25112;
  goto <D.25113>;
  <D.25110>:
  D.25112 = mono_defaults.uint16_class;
  if (D.25112 == eclass) goto <D.25114>; else goto <D.25115>;
  <D.25114>:
  D.25111 = valuetype_types + 4;
  D.25108 = mono_defaults.int16_class;
  *D.25111 = D.25108;
  goto <D.25116>;
  <D.25115>:
  D.25117 = mono_defaults.int32_class;
  if (D.25117 == eclass) goto <D.25118>; else goto <D.25119>;
  <D.25118>:
  D.25111 = valuetype_types + 4;
  D.25120 = mono_defaults.uint32_class;
  *D.25111 = D.25120;
  goto <D.25121>;
  <D.25119>:
  D.25120 = mono_defaults.uint32_class;
  if (D.25120 == eclass) goto <D.25122>; else goto <D.25123>;
  <D.25122>:
  D.25111 = valuetype_types + 4;
  D.25117 = mono_defaults.int32_class;
  *D.25111 = D.25117;
  goto <D.25124>;
  <D.25123>:
  D.25125 = mono_defaults.int64_class;
  if (D.25125 == eclass) goto <D.25126>; else goto <D.25127>;
  <D.25126>:
  D.25111 = valuetype_types + 4;
  D.25128 = mono_defaults.uint64_class;
  *D.25111 = D.25128;
  goto <D.25129>;
  <D.25127>:
  D.25128 = mono_defaults.uint64_class;
  if (D.25128 == eclass) goto <D.25130>; else goto <D.25131>;
  <D.25130>:
  D.25111 = valuetype_types + 4;
  D.25125 = mono_defaults.int64_class;
  *D.25111 = D.25125;
  goto <D.25132>;
  <D.25131>:
  D.25133 = mono_defaults.byte_class;
  if (D.25133 == eclass) goto <D.25134>; else goto <D.25135>;
  <D.25134>:
  D.25111 = valuetype_types + 4;
  D.25136 = mono_defaults.sbyte_class;
  *D.25111 = D.25136;
  goto <D.25137>;
  <D.25135>:
  D.25136 = mono_defaults.sbyte_class;
  if (D.25136 == eclass) goto <D.25138>; else goto <D.25139>;
  <D.25138>:
  D.25111 = valuetype_types + 4;
  D.25133 = mono_defaults.byte_class;
  *D.25111 = D.25133;
  goto <D.25140>;
  <D.25139>:
  D.25141 = BIT_FIELD_REF <*eclass, 8, 160>;
  D.25142 = D.25141 & 16;
  if (D.25142 != 0) goto <D.25143>; else goto <D.25144>;
  <D.25143>:
  D.25145 = mono_class_enum_basetype (eclass);
  if (D.25145 != 0B) goto <D.25146>; else goto <D.25147>;
  <D.25146>:
  D.25111 = valuetype_types + 4;
  D.25148 = mono_class_enum_basetype (eclass);
  D.25149 = mono_class_from_mono_type (D.25148);
  *D.25111 = D.25149;
  <D.25147>:
  <D.25144>:
  <D.25140>:
  <D.25137>:
  <D.25132>:
  <D.25129>:
  <D.25124>:
  <D.25121>:
  <D.25116>:
  <D.25113>:
}


array_class_get_if_rank (struct MonoClass * class, guint rank)
{
  struct MonoClass * D.25150;
  struct MonoClass * iftmp.184;

  if (rank != 0) goto <D.25152>; else goto <D.25153>;
  <D.25152>:
  iftmp.184 = mono_array_class_get (class, rank);
  goto <D.25154>;
  <D.25153>:
  iftmp.184 = class;
  <D.25154>:
  D.25150 = iftmp.184;
  return D.25150;
}


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

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


count_virtual_methods (struct MonoClass * class)
{
  struct MonoMethod * * D.25162;
  unsigned int D.25164;
  struct MonoImage * D.25166;
  unsigned char D.25167;
  unsigned char D.25168;
  struct MonoGenericClass * D.25170;
  unsigned char D.25171;
  int D.25174;
  unsigned int i.185;
  unsigned int D.25176;
  struct MonoMethod * * D.25177;
  struct MonoMethod * D.25178;
  short unsigned int D.25179;
  unsigned int D.25180;
  unsigned int i.186;
  unsigned int D.25184;
  unsigned int D.25185;
  unsigned int D.25186;
  int D.25187;
  int i;
  int count;
  guint32 flags;

  count = 0;
  class = mono_class_get_generic_type_definition (class);
  D.25162 = class->methods;
  if (D.25162 != 0B) goto <D.25160>; else goto <D.25163>;
  <D.25163>:
  D.25164 = class->type_token;
  if (D.25164 == 0) goto <D.25160>; else goto <D.25165>;
  <D.25165>:
  D.25166 = class->image;
  D.25167 = BIT_FIELD_REF <*D.25166, 8, 128>;
  D.25168 = D.25167 & 8;
  if (D.25168 != 0) goto <D.25160>; else goto <D.25169>;
  <D.25169>:
  D.25170 = class->generic_class;
  if (D.25170 != 0B) goto <D.25160>; else goto <D.25161>;
  <D.25160>:
  mono_class_setup_methods (class);
  D.25171 = class->exception_type;
  if (D.25171 != 0) goto <D.25172>; else goto <D.25173>;
  <D.25172>:
  D.25174 = -1;
  return D.25174;
  <D.25173>:
  i = 0;
  goto <D.19248>;
  <D.19247>:
  D.25162 = class->methods;
  i.185 = (unsigned int) i;
  D.25176 = i.185 * 4;
  D.25177 = D.25162 + D.25176;
  D.25178 = *D.25177;
  D.25179 = D.25178->flags;
  flags = (guint32) D.25179;
  D.25180 = flags & 64;
  if (D.25180 != 0) goto <D.25181>; else goto <D.25182>;
  <D.25181>:
  count = count + 1;
  <D.25182>:
  i = i + 1;
  <D.19248>:
  i.186 = (unsigned int) i;
  D.25184 = class->method.count;
  if (i.186 < D.25184) goto <D.19247>; else goto <D.19249>;
  <D.19249>:
  goto <D.19252>;
  <D.25161>:
  i = 0;
  goto <D.19251>;
  <D.19250>:
  D.25185 = class->method.first;
  i.186 = (unsigned int) i;
  D.25186 = D.25185 + i.186;
  D.25187 = (int) D.25186;
  D.25166 = class->image;
  flags = mono_metadata_decode_table_row_col (D.25166, 6, D.25187, 2);
  D.25180 = flags & 64;
  if (D.25180 != 0) goto <D.25188>; else goto <D.25189>;
  <D.25188>:
  count = count + 1;
  <D.25189>:
  i = i + 1;
  <D.19251>:
  i.186 = (unsigned int) i;
  D.25184 = class->method.count;
  if (i.186 < D.25184) goto <D.19250>; else goto <D.19252>;
  <D.19252>:
  D.25174 = count;
  return D.25174;
}


find_array_interface (struct MonoClass * klass, const char * name)
{
  int D.19237;
  struct MonoClass * * D.25191;
  unsigned int i.187;
  unsigned int D.25193;
  struct MonoClass * * D.25194;
  struct MonoClass * D.25195;
  const char * D.25196;
  int D.25199;
  short unsigned int D.25200;
  int D.25201;
  int i;

  i = 0;
  goto <D.19239>;
  <D.19238>:
  {
    size_t __s1_len;
    size_t __s2_len;

    D.25191 = klass->interfaces;
    i.187 = (unsigned int) i;
    D.25193 = i.187 * 4;
    D.25194 = D.25191 + D.25193;
    D.25195 = *D.25194;
    D.25196 = D.25195->name;
    D.19237 = __builtin_strcmp (D.25196, name);
  }
  if (D.19237 == 0) goto <D.25197>; else goto <D.25198>;
  <D.25197>:
  D.25199 = i;
  return D.25199;
  <D.25198>:
  i = i + 1;
  <D.19239>:
  D.25200 = klass->interface_count;
  D.25201 = (int) D.25200;
  if (D.25201 > i) goto <D.19238>; else goto <D.19240>;
  <D.19240>:
  D.25199 = -1;
  return D.25199;
}


find_interface_offset (int num_ifaces, struct MonoClass * * interfaces_full, int * interface_offsets_full, struct MonoClass * ic)
{
  int D.25205;
  unsigned int i.188;
  unsigned int D.25207;
  int * D.25208;
  int i;

  i = find_interface (num_ifaces, interfaces_full, ic);
  if (1 != 0) goto <D.25203>; else goto <D.25204>;
  <D.25203>:
  i.188 = (unsigned int) i;
  D.25207 = i.188 * 4;
  D.25208 = interface_offsets_full + D.25207;
  D.25205 = *D.25208;
  return D.25205;
  <D.25204>:
  D.25205 = -1;
  return D.25205;
}


find_interface (int num_ifaces, struct MonoClass * * interfaces_full, struct MonoClass * ic)
{
  int D.25212;
  int D.25215;
  unsigned int m.189;
  unsigned int D.25217;
  struct MonoClass * * D.25218;
  struct MonoClass * D.25219;
  short unsigned int D.25228;
  short unsigned int D.25229;
  int m;
  int l;

  l = 0;
  if (num_ifaces == 0) goto <D.25210>; else goto <D.25211>;
  <D.25210>:
  D.25212 = -1;
  return D.25212;
  <D.25211>:
  <D.19260>:
  if (l > num_ifaces) goto <D.25213>; else goto <D.25214>;
  <D.25213>:
  D.25212 = -1;
  return D.25212;
  <D.25214>:
  D.25215 = l + num_ifaces;
  m = D.25215 / 2;
  m.189 = (unsigned int) m;
  D.25217 = m.189 * 4;
  D.25218 = interfaces_full + D.25217;
  D.25219 = *D.25218;
  if (D.25219 == ic) goto <D.25220>; else goto <D.25221>;
  <D.25220>:
  D.25212 = m;
  return D.25212;
  <D.25221>:
  if (l == num_ifaces) goto <D.25222>; else goto <D.25223>;
  <D.25222>:
  D.25212 = -1;
  return D.25212;
  <D.25223>:
  m.189 = (unsigned int) m;
  D.25217 = m.189 * 4;
  D.25218 = interfaces_full + D.25217;
  D.25219 = *D.25218;
  if (D.25219 == 0B) goto <D.25224>; else goto <D.25227>;
  <D.25227>:
  m.189 = (unsigned int) m;
  D.25217 = m.189 * 4;
  D.25218 = interfaces_full + D.25217;
  D.25219 = *D.25218;
  D.25228 = D.25219->interface_id;
  D.25229 = ic->interface_id;
  if (D.25228 > D.25229) goto <D.25224>; else goto <D.25225>;
  <D.25224>:
  num_ifaces = m + -1;
  goto <D.25226>;
  <D.25225>:
  l = m + 1;
  <D.25226>:
  goto <D.19260>;
}


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.25235;
  unsigned int i.190;
  unsigned int D.25237;
  int * D.25238;
  struct MonoClass * * D.25239;
  struct MonoClass * D.25240;
  short unsigned int D.25243;
  short unsigned int D.25244;
  unsigned int end.191;
  unsigned int D.25249;
  struct MonoClass * * D.25250;
  struct MonoClass * D.25251;
  int D.25252;
  unsigned int D.25253;
  unsigned int D.25254;
  const void * D.25255;
  sizetype i.192;
  sizetype D.25257;
  sizetype D.25258;
  struct MonoClass * * D.25259;
  const void * D.25260;
  int * D.25261;
  int i;

  i = find_interface (num_ifaces, interfaces_full, ic);
  if (i >= 0) goto <D.25231>; else goto <D.25232>;
  <D.25231>:
  if (force_set == 0) goto <D.25233>; else goto <D.25234>;
  <D.25233>:
  D.25235 = 1;
  return D.25235;
  <D.25234>:
  i.190 = (unsigned int) i;
  D.25237 = i.190 * 4;
  D.25238 = interface_offsets_full + D.25237;
  *D.25238 = offset;
  D.25235 = 0;
  return D.25235;
  <D.25232>:
  i = 0;
  goto <D.19284>;
  <D.19283>:
  i.190 = (unsigned int) i;
  D.25237 = i.190 * 4;
  D.25239 = interfaces_full + D.25237;
  D.25240 = *D.25239;
  if (D.25240 != 0B) goto <D.25241>; else goto <D.25242>;
  <D.25241>:
  {
    int end;

    i.190 = (unsigned int) i;
    D.25237 = i.190 * 4;
    D.25239 = interfaces_full + D.25237;
    D.25240 = *D.25239;
    D.25243 = D.25240->interface_id;
    D.25244 = ic->interface_id;
    if (D.25243 < D.25244) goto <D.25245>; else goto <D.25246>;
    <D.25245>:
    // predicted unlikely by continue predictor.
    goto <D.19278>;
    <D.25246>:
    end = i + 1;
    goto <D.19280>;
    <D.19279>:
    end = end + 1;
    <D.19280>:
    if (end < num_ifaces) goto <D.25247>; else goto <D.19281>;
    <D.25247>:
    end.191 = (unsigned int) end;
    D.25249 = end.191 * 4;
    D.25250 = interfaces_full + D.25249;
    D.25251 = *D.25250;
    if (D.25251 != 0B) goto <D.19279>; else goto <D.19281>;
    <D.19281>:
    D.25252 = end - i;
    D.25253 = (unsigned int) D.25252;
    D.25254 = D.25253 * 4;
    i.190 = (unsigned int) i;
    D.25237 = i.190 * 4;
    D.25255 = interfaces_full + D.25237;
    i.192 = (sizetype) i;
    D.25257 = i.192 + 1;
    D.25258 = D.25257 * 4;
    D.25259 = interfaces_full + D.25258;
    memmove (D.25259, D.25255, D.25254);
    D.25252 = end - i;
    D.25253 = (unsigned int) D.25252;
    D.25254 = D.25253 * 4;
    i.190 = (unsigned int) i;
    D.25237 = i.190 * 4;
    D.25260 = interface_offsets_full + D.25237;
    i.192 = (sizetype) i;
    D.25257 = i.192 + 1;
    D.25258 = D.25257 * 4;
    D.25261 = interface_offsets_full + D.25258;
    memmove (D.25261, D.25260, D.25254);
  }
  <D.25242>:
  i.190 = (unsigned int) i;
  D.25237 = i.190 * 4;
  D.25239 = interfaces_full + D.25237;
  *D.25239 = ic;
  i.190 = (unsigned int) i;
  D.25237 = i.190 * 4;
  D.25238 = interface_offsets_full + D.25237;
  *D.25238 = offset;
  goto <D.19282>;
  <D.19278>:
  i = i + 1;
  <D.19284>:
  if (i < num_ifaces) goto <D.19283>; else goto <D.19282>;
  <D.19282>:
  D.25235 = 0;
  return D.25235;
}


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

  D.25264 = __builtin_object_size (__dest, 0);
  D.25263 = __builtin___memmove_chk (__dest, __src, __len, D.25264);
  return D.25263;
}


mono_class_check_vtable_constraints (struct MonoClass * class, struct GList * in_setup)
{
  struct MonoGenericClass * D.25266;
  gboolean D.25269;
  unsigned char D.25270;
  _Bool D.25271;
  struct MonoClass * D.25272;
  struct MonoClass * D.25273;
  unsigned char D.25274;
  gchar * D.25277;
  struct MonoType * D.25278;
  unsigned char D.25279;
  int D.25284;
  int D.25286;
  int D.25287;
  gchar * D.25290;
  <unnamed-unsigned:22> D.25291;
  int D.25292;
  struct MonoGenericInst * ginst;
  int i;

  D.25266 = class->generic_class;
  if (D.25266 == 0B) goto <D.25267>; else goto <D.25268>;
  <D.25267>:
  mono_class_setup_vtable_full (class, in_setup);
  D.25270 = class->exception_type;
  D.25271 = D.25270 == 0;
  D.25269 = (gboolean) D.25271;
  return D.25269;
  <D.25268>:
  D.25272 = mono_class_get_generic_type_definition (class);
  mono_class_setup_vtable_full (D.25272, in_setup);
  D.25266 = class->generic_class;
  D.25273 = D.25266->container_class;
  D.25274 = D.25273->exception_type;
  if (D.25274 != 0) goto <D.25275>; else goto <D.25276>;
  <D.25275>:
  D.25277 = monoeg_strdup ("Failed to load generic definition vtable");
  mono_class_set_failure (class, 7, D.25277);
  D.25269 = 0;
  return D.25269;
  <D.25276>:
  D.25266 = class->generic_class;
  ginst = D.25266->context.class_inst;
  i = 0;
  goto <D.19429>;
  <D.19428>:
  {
    struct MonoClass * arg;

    D.25278 = ginst->type_argv[i];
    D.25279 = D.25278->type;
    if (D.25279 != 21) goto <D.25280>; else goto <D.25281>;
    <D.25280>:
    // predicted unlikely by continue predictor.
    goto <D.19427>;
    <D.25281>:
    D.25278 = ginst->type_argv[i];
    arg = mono_class_from_mono_type (D.25278);
    D.25284 = mono_class_has_gtd_parent (class, arg);
    if (D.25284 != 0) goto <D.25282>; else goto <D.25285>;
    <D.25285>:
    D.25286 = mono_class_has_gtd_parent (arg, class);
    if (D.25286 != 0) goto <D.25282>; else goto <D.25283>;
    <D.25282>:
    // predicted unlikely by continue predictor.
    goto <D.19427>;
    <D.25283>:
    D.25287 = mono_class_check_vtable_constraints (arg, in_setup);
    if (D.25287 == 0) goto <D.25288>; else goto <D.25289>;
    <D.25288>:
    D.25290 = monoeg_g_strdup_printf ("Failed to load generic parameter %d", i);
    mono_class_set_failure (class, 7, D.25290);
    D.25269 = 0;
    return D.25269;
    <D.25289>:
  }
  <D.19427>:
  i = i + 1;
  <D.19429>:
  D.25291 = ginst->type_argc;
  D.25292 = (int) D.25291;
  if (D.25292 > i) goto <D.19428>; else goto <D.19430>;
  <D.19430>:
  D.25269 = 1;
  return D.25269;
}


mono_class_setup_vtable_full (struct MonoClass * class, struct GList * in_setup)
{
  struct MonoMethod * * D.25294;
  unsigned int D.25299;
  unsigned int D.25300;
  unsigned char D.25302;
  unsigned char D.25304;
  struct GList * D.25307;
  long unsigned int D.25312;
  long unsigned int D.25313;
  struct MonoGenericClass * D.25314;
  int D.25317;
  struct MonoClass * D.25320;
  struct MonoImage * D.25322;
  unsigned char D.25323;
  unsigned char D.25324;
  int onum.193;
  struct MonoMethod * * overrides.194;
  gchar * D.25333;
  struct MonoMethod * * overrides;
  struct MonoGenericContext * context;
  guint32 type_token;
  int onum;
  gboolean ok;

  try
    {
      onum = 0;
      ok = 1;
      D.25294 = class->vtable;
      if (D.25294 != 0B) goto <D.25295>; else goto <D.25296>;
      <D.25295>:
      return;
      <D.25296>:
      D.25299 = class->flags;
      D.25300 = D.25299 & 32;
      if (D.25300 != 0) goto <D.25297>; else goto <D.25301>;
      <D.25301>:
      D.25302 = class->byval_arg.type;
      if (D.25302 == 19) goto <D.25297>; else goto <D.25303>;
      <D.25303>:
      D.25302 = class->byval_arg.type;
      if (D.25302 == 30) goto <D.25297>; else goto <D.25298>;
      <D.25297>:
      mono_class_setup_methods (class);
      return;
      <D.25298>:
      D.25304 = class->exception_type;
      if (D.25304 != 0) goto <D.25305>; else goto <D.25306>;
      <D.25305>:
      return;
      <D.25306>:
      D.25307 = monoeg_g_list_find (in_setup, class);
      if (D.25307 != 0B) goto <D.25308>; else goto <D.25309>;
      <D.25308>:
      return;
      <D.25309>:
      mono_loader_lock ();
      D.25294 = class->vtable;
      if (D.25294 != 0B) goto <D.25310>; else goto <D.25311>;
      <D.25310>:
      mono_loader_unlock ();
      return;
      <D.25311>:
      D.25312 = mono_stats.generic_vtable_count;
      D.25313 = D.25312 + 1;
      mono_stats.generic_vtable_count = D.25313;
      in_setup = monoeg_g_list_prepend (in_setup, class);
      D.25314 = class->generic_class;
      if (D.25314 != 0B) goto <D.25315>; else goto <D.25316>;
      <D.25315>:
      D.25317 = mono_class_check_vtable_constraints (class, in_setup);
      if (D.25317 == 0) goto <D.25318>; else goto <D.25319>;
      <D.25318>:
      mono_loader_unlock ();
      monoeg_g_list_remove (in_setup, class);
      return;
      <D.25319>:
      context = mono_class_get_context (class);
      D.25314 = class->generic_class;
      D.25320 = D.25314->container_class;
      type_token = D.25320->type_token;
      goto <D.25321>;
      <D.25316>:
      context = class->generic_container;
      type_token = class->type_token;
      <D.25321>:
      D.25322 = class->image;
      D.25323 = BIT_FIELD_REF <*D.25322, 8, 128>;
      D.25324 = D.25323 & 8;
      if (D.25324 != 0) goto <D.25325>; else goto <D.25326>;
      <D.25325>:
      mono_reflection_get_dynamic_overrides (class, &overrides, &onum);
      goto <D.25327>;
      <D.25326>:
      D.25322 = class->image;
      ok = mono_class_get_overrides_full (D.25322, type_token, &overrides, &onum, context);
      <D.25327>:
      if (ok != 0) goto <D.25328>; else goto <D.25329>;
      <D.25328>:
      onum.193 = onum;
      overrides.194 = overrides;
      mono_class_setup_vtable_general (class, overrides.194, onum.193, in_setup);
      goto <D.25332>;
      <D.25329>:
      D.25333 = monoeg_strdup ("Could not load list of method overrides");
      mono_class_set_failure (class, 7, D.25333);
      <D.25332>:
      overrides.194 = overrides;
      monoeg_g_free (overrides.194);
      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.25336;
  int iftmp.195;
  short unsigned int D.25340;
  short unsigned int D.25341;
  struct MonoClass * * D.25343;
  sizetype D.25344;
  sizetype D.25345;
  sizetype D.25346;
  struct MonoClass * * D.25347;
  struct MonoClass * D.25348;
  struct MonoClass * D.25349;

  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.25340 = klass->idepth;
  D.25341 = parent->idepth;
  if (D.25340 >= D.25341) goto <D.25342>; else goto <D.25338>;
  <D.25342>:
  D.25343 = klass->supertypes;
  D.25341 = parent->idepth;
  D.25344 = (sizetype) D.25341;
  D.25345 = D.25344 + 1073741823;
  D.25346 = D.25345 * 4;
  D.25347 = D.25343 + D.25346;
  D.25348 = *D.25347;
  D.25349 = mono_class_get_generic_type_definition (D.25348);
  if (D.25349 == parent) goto <D.25350>; else goto <D.25338>;
  <D.25350>:
  iftmp.195 = 1;
  goto <D.25339>;
  <D.25338>:
  iftmp.195 = 0;
  <D.25339>:
  D.25336 = iftmp.195;
  return D.25336;
}


mono_class_setup_vtable (struct MonoClass * class)
{
  mono_class_setup_vtable_full (class, 0B);
}


mono_class_setup_vtable_general (struct MonoClass * class, struct MonoMethod * * overrides, int onum, struct GList * in_setup)
{
  struct MonoMethod * * D.25352;
  int D.25357;
  int D.25360;
  const char * D.25363;
  gchar * D.25364;
  void * * D.25367;
  unsigned int i.196;
  unsigned int D.25369;
  void * * D.25370;
  unsigned int D.25371;
  unsigned int max_vtsize.197;
  unsigned int D.25373;
  unsigned int i.198;
  unsigned int D.25375;
  struct MonoClass * D.25376;
  unsigned char D.25379;
  gchar * D.25382;
  int D.25383;
  unsigned int D.25384;
  unsigned int D.25385;
  int D.25386;
  unsigned int max_vtsize.199;
  unsigned int D.25390;
  short unsigned int D.25393;
  struct MonoGenericClass * D.25394;
  unsigned char D.25397;
  int D.25400;
  unsigned int D.25401;
  unsigned int D.25402;
  int D.25403;
  struct MonoMethod * * D.25404;
  struct MonoMethod * * D.25405;
  struct MonoMethod * D.25406;
  struct MonoGenericContext * D.25409;
  int D.25410;
  const char * D.25413;
  struct MonoMethod * * D.25414;
  struct MonoMethod * D.25415;
  short int D.25416;
  struct MonoMethod * * D.25417;
  struct MonoMethod * * D.25420;
  struct MonoMethod * * D.25423;
  struct MonoMethod * D.25424;
  short int D.25425;
  struct MonoMethod * * D.25428;
  struct MonoMethod * D.25429;
  short int D.25430;
  unsigned int i.200;
  int D.25436;
  unsigned int D.25437;
  unsigned int D.25438;
  struct MonoMethod * * D.25439;
  struct MonoClass * * D.25440;
  unsigned int i.201;
  unsigned int D.25442;
  struct MonoClass * * D.25443;
  int D.25446;
  unsigned int D.25447;
  unsigned int D.25448;
  struct MonoMethod * * D.25449;
  int D.25450;
  unsigned int D.25451;
  unsigned int D.25452;
  struct MonoMethod * * D.25453;
  struct MonoMethod * D.25454;
  unsigned int j.202;
  unsigned int D.25456;
  unsigned char D.25458;
  short unsigned int D.25459;
  int D.25460;
  int D.25461;
  short int D.25464;
  short int D.25467;
  int D.25469;
  _Bool D.25470;
  long int D.25471;
  long int D.25472;
  unsigned int stelemref_slot.203;
  unsigned int D.25476;
  struct MonoMethod * * D.25477;
  unsigned int D.25478;
  struct MonoMethod * * D.25479;
  struct MonoClass * D.25482;
  unsigned int D.25483;
  unsigned int D.25484;
  unsigned char D.25486;
  int D.25490;
  unsigned int dslot.204;
  unsigned int D.25492;
  struct MonoMethod * * D.25493;
  sizetype i.205;
  sizetype D.25495;
  sizetype D.25496;
  struct MonoMethod * * D.25497;
  struct MonoMethod * D.25498;
  struct MonoMethod * D.25499;
  short int D.25500;
  struct MonoMethod * D.25503;
  <unnamed type> D.25504;
  struct MonoClass * * D.25508;
  struct MonoClass * * D.25509;
  unsigned char D.25510;
  struct MonoClass * * D.25514;
  unsigned int implemented_interfaces_index.206;
  unsigned int D.25516;
  struct MonoClass * * D.25517;
  struct MonoClass * D.25518;
  short unsigned int D.25521;
  int D.25522;
  struct MonoMethod * * D.25524;
  unsigned int im_index.207;
  unsigned int D.25526;
  struct MonoMethod * * D.25527;
  short int D.25528;
  int D.25529;
  struct MonoMethod * iftmp.208;
  short unsigned int D.25534;
  int D.25535;
  int D.25536;
  unsigned int im_slot.209;
  unsigned int D.25542;
  struct MonoMethod * * D.25543;
  struct MonoMethod * D.25544;
  _Bool D.25545;
  int D.25546;
  int D.25547;
  short int D.25550;
  short int D.25553;
  int D.25559;
  struct MonoMethod * * D.25560;
  unsigned int cm_index.210;
  unsigned int D.25562;
  struct MonoMethod * * D.25563;
  int D.25566;
  short int D.25569;
  _Bool D.25574;
  long int D.25575;
  long int D.25576;
  unsigned int im_index.211;
  unsigned int D.25580;
  short unsigned int D.25581;
  int D.25582;
  unsigned int D.25583;
  unsigned int D.25584;
  unsigned int im_index.212;
  unsigned int D.25588;
  struct MonoMethod * * D.25589;
  short int D.25590;
  int D.25591;
  short unsigned int D.25592;
  int D.25593;
  int D.25594;
  unsigned int im_slot.213;
  unsigned int D.25598;
  struct MonoMethod * * D.25599;
  struct MonoMethod * D.25600;
  unsigned int im_index.214;
  short unsigned int D.25604;
  int D.25605;
  int D.25606;
  _Bool D.25609;
  _Bool D.25610;
  _Bool D.25611;
  int D.19696;
  const char * D.25614;
  const char * D.25615;
  int D.25618;
  short unsigned int D.25623;
  int D.25624;
  int D.25625;
  <unnamed type> D.25628;
  int D.25632;
  int D.25635;
  gchar * D.25638;
  short int D.25639;
  int D.25640;
  _Bool D.25641;
  long int D.25642;
  long int D.25643;
  unsigned char D.25648;
  short int D.25653;
  unsigned int D.25654;
  unsigned int D.25655;
  int cur_slot.215;
  short int D.25663;
  int D.25664;
  unsigned int D.25667;
  unsigned int D.25668;
  struct MonoMethod * * D.25669;
  struct MonoClass * D.25670;
  unsigned int D.25671;
  unsigned int D.25672;
  unsigned char D.25675;
  short int D.25680;
  _Bool D.25681;
  long int D.25682;
  long int D.25683;
  unsigned int D.25686;
  unsigned int D.25687;
  struct MonoMethod * * D.25688;
  <unnamed type> D.25691;
  struct MonoMethod * D.25694;
  struct MonoMethod * * D.25697;
  struct MonoMethod * D.25698;
  short unsigned int D.25708;
  int D.25709;
  int D.25710;
  char * iftmp.216;
  gchar * D.25715;
  int D.25718;
  int D.25719;
  int D.25721;
  _Bool D.25724;
  long int D.25725;
  long int D.25726;
  unsigned int D.25733;
  unsigned int D.25734;
  struct MonoMethod * * D.25735;
  int D.25736;
  int D.25738;
  int mono_print_vtable.217;
  int D.25742;
  guint8 * D.25745;
  int D.25746;
  sizetype D.25747;
  guint8 * D.25748;
  unsigned char D.25749;
  int D.25750;
  int D.25751;
  int D.25752;
  int D.25753;
  struct MonoType * D.25756;
  char * D.25757;
  char * D.25760;
  short int D.25761;
  int D.25762;
  const char * D.25765;
  const char * D.25766;
  struct MonoClass * * D.25767;
  struct MonoType * D.25768;
  char * D.25769;
  short unsigned int D.25770;
  int D.25771;
  int D.25772;
  int D.25773;
  struct MonoClass * * D.25774;
  struct MonoClass * * D.25775;
  char * D.25776;
  int D.25777;
  int D.25778;
  short unsigned int D.25779;
  int D.25780;
  gchar * D.25781;
  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.25352 = class->vtable;
      if (D.25352 != 0B) goto <D.25353>; else goto <D.25354>;
      <D.25353>:
      return;
      <D.25354>:
      if (overrides != 0B) goto <D.25355>; else goto <D.25356>;
      <D.25355>:
      D.25357 = verify_class_overrides (class, overrides, onum);
      if (D.25357 == 0) goto <D.25358>; else goto <D.25359>;
      <D.25358>:
      return;
      <D.25359>:
      <D.25356>:
      ifaces = mono_class_get_implemented_interfaces (class, &error);
      D.25360 = mono_error_ok (&error);
      if (D.25360 == 0) goto <D.25361>; else goto <D.25362>;
      <D.25361>:
      {
        char * name;

        name = mono_type_get_full_name (class);
        D.25363 = mono_error_get_message (&error);
        D.25364 = monoeg_g_strdup_printf ("Could not resolve %s interfaces due to %s", name, D.25363);
        mono_class_set_failure (class, 7, D.25364);
        monoeg_g_free (name);
        mono_error_cleanup (&error);
        return;
      }
      <D.25362>:
      if (ifaces != 0B) goto <D.25365>; else goto <D.25366>;
      <D.25365>:
      i = 0;
      goto <D.19605>;
      <D.19604>:
      {
        struct MonoClass * ic;

        D.25367 = ifaces->pdata;
        i.196 = (unsigned int) i;
        D.25369 = i.196 * 4;
        D.25370 = D.25367 + D.25369;
        ic = *D.25370;
        D.25371 = ic->method.count;
        max_vtsize.197 = (unsigned int) max_vtsize;
        D.25373 = D.25371 + max_vtsize.197;
        max_vtsize = (int) D.25373;
      }
      i = i + 1;
      <D.19605>:
      i.198 = (unsigned int) i;
      D.25375 = ifaces->len;
      if (i.198 < D.25375) goto <D.19604>; else goto <D.19606>;
      <D.19606>:
      monoeg_g_ptr_array_free (ifaces, 1);
      ifaces = 0B;
      <D.25366>:
      D.25376 = class->parent;
      if (D.25376 != 0B) goto <D.25377>; else goto <D.25378>;
      <D.25377>:
      D.25376 = class->parent;
      mono_class_init (D.25376);
      D.25376 = class->parent;
      mono_class_setup_vtable_full (D.25376, in_setup);
      D.25376 = class->parent;
      D.25379 = D.25376->exception_type;
      if (D.25379 != 0) goto <D.25380>; else goto <D.25381>;
      <D.25380>:
      {
        char * name;

        D.25376 = class->parent;
        name = mono_type_get_full_name (D.25376);
        D.25382 = monoeg_g_strdup_printf ("Parent %s failed to load", name);
        mono_class_set_failure (class, 7, D.25382);
        monoeg_g_free (name);
        return;
      }
      <D.25381>:
      D.25376 = class->parent;
      D.25383 = D.25376->vtable_size;
      max_vtsize = D.25383 + max_vtsize;
      D.25376 = class->parent;
      cur_slot = D.25376->vtable_size;
      <D.25378>:
      D.25384 = class->method.count;
      max_vtsize.197 = (unsigned int) max_vtsize;
      D.25385 = D.25384 + max_vtsize.197;
      max_vtsize = (int) D.25385;
      D.25386 = mono_class_need_stelemref_method (class);
      if (D.25386 != 0) goto <D.25387>; else goto <D.25388>;
      <D.25387>:
      stelemref_slot = cur_slot;
      max_vtsize = max_vtsize + 1;
      cur_slot = cur_slot + 1;
      <D.25388>:
      max_vtsize.199 = (unsigned int) max_vtsize;
      D.25390 = max_vtsize.199 * 4;
      vtable = __builtin_alloca (D.25390);
      max_vtsize.199 = (unsigned int) max_vtsize;
      D.25390 = max_vtsize.199 * 4;
      memset (vtable, 0, D.25390);
      cur_slot = setup_interface_offsets (class, cur_slot, 1);
      if (cur_slot == -1) goto <D.25391>; else goto <D.25392>;
      <D.25391>:
      return;
      <D.25392>:
      D.25393 = class->max_interface_id;
      max_iid = (int) D.25393;
      D.25394 = class->generic_class;
      if (D.25394 != 0B) goto <D.25395>; else goto <D.25396>;
      <D.25395>:
      {
        struct MonoError error;
        struct MonoClass * gklass;
        struct MonoMethod * * tmp;

        try
          {
            D.25394 = class->generic_class;
            gklass = D.25394->container_class;
            mono_class_setup_vtable_full (gklass, in_setup);
            D.25397 = gklass->exception_type;
            if (D.25397 != 0) goto <D.25398>; else goto <D.25399>;
            <D.25398>:
            mono_class_set_failure (class, 7, 0B);
            return;
            <D.25399>:
            D.25400 = gklass->vtable_size;
            D.25401 = (unsigned int) D.25400;
            D.25402 = D.25401 * 4;
            D.25403 = (int) D.25402;
            tmp = mono_class_alloc0 (class, D.25403);
            D.25400 = gklass->vtable_size;
            class->vtable_size = D.25400;
            i = 0;
            goto <D.19614>;
            <D.19613>:
            D.25404 = gklass->vtable;
            i.196 = (unsigned int) i;
            D.25369 = i.196 * 4;
            D.25405 = D.25404 + D.25369;
            D.25406 = *D.25405;
            if (D.25406 != 0B) goto <D.25407>; else goto <D.25408>;
            <D.25407>:
            {
              struct MonoMethod * inflated;

              D.25409 = mono_class_get_context (class);
              D.25404 = gklass->vtable;
              i.196 = (unsigned int) i;
              D.25369 = i.196 * 4;
              D.25405 = D.25404 + D.25369;
              D.25406 = *D.25405;
              inflated = mono_class_inflate_generic_method_full_checked (D.25406, class, D.25409, &error);
              D.25410 = mono_error_ok (&error);
              if (D.25410 == 0) goto <D.25411>; else goto <D.25412>;
              <D.25411>:
              {
                char * err_msg;

                D.25413 = mono_error_get_message (&error);
                err_msg = monoeg_g_strdup_printf ("Could not inflate method due to %s", D.25413);
                mono_class_set_failure (class, 7, err_msg);
                monoeg_g_free (err_msg);
                mono_error_cleanup (&error);
                return;
              }
              <D.25412>:
              i.196 = (unsigned int) i;
              D.25369 = i.196 * 4;
              D.25414 = tmp + D.25369;
              *D.25414 = inflated;
              i.196 = (unsigned int) i;
              D.25369 = i.196 * 4;
              D.25414 = tmp + D.25369;
              D.25415 = *D.25414;
              D.25404 = gklass->vtable;
              i.196 = (unsigned int) i;
              D.25369 = i.196 * 4;
              D.25405 = D.25404 + D.25369;
              D.25406 = *D.25405;
              D.25416 = D.25406->slot;
              D.25415->slot = D.25416;
            }
            <D.25408>:
            i = i + 1;
            <D.19614>:
            D.25400 = gklass->vtable_size;
            if (D.25400 > i) goto <D.19613>; else goto <D.19615>;
            <D.19615>:
            mono_memory_barrier ();
            class->vtable = tmp;
            D.25417 = class->methods;
            if (D.25417 != 0B) goto <D.25418>; else goto <D.25419>;
            <D.25418>:
            D.25420 = gklass->methods;
            if (D.25420 != 0B) goto <D.25421>; else goto <D.25422>;
            <D.25421>:
            i = 0;
            goto <D.19617>;
            <D.19616>:
            D.25417 = class->methods;
            i.196 = (unsigned int) i;
            D.25369 = i.196 * 4;
            D.25423 = D.25417 + D.25369;
            D.25424 = *D.25423;
            D.25425 = D.25424->slot;
            if (D.25425 == -1) goto <D.25426>; else goto <D.25427>;
            <D.25426>:
            D.25417 = class->methods;
            i.196 = (unsigned int) i;
            D.25369 = i.196 * 4;
            D.25423 = D.25417 + D.25369;
            D.25424 = *D.25423;
            D.25420 = gklass->methods;
            i.196 = (unsigned int) i;
            D.25369 = i.196 * 4;
            D.25428 = D.25420 + D.25369;
            D.25429 = *D.25428;
            D.25430 = D.25429->slot;
            D.25424->slot = D.25430;
            <D.25427>:
            i = i + 1;
            <D.19617>:
            i.200 = (unsigned int) i;
            D.25384 = class->method.count;
            if (i.200 < D.25384) goto <D.19616>; else goto <D.19618>;
            <D.19618>:
            <D.25422>:
            <D.25419>:
            return;
          }
        finally
          {
            error = {CLOBBER};
          }
      }
      <D.25396>:
      D.25376 = class->parent;
      if (D.25376 != 0B) goto <D.25432>; else goto <D.25433>;
      <D.25432>:
      D.25376 = class->parent;
      D.25383 = D.25376->vtable_size;
      if (D.25383 != 0) goto <D.25434>; else goto <D.25435>;
      <D.25434>:
      {
        struct MonoClass * parent;
        int i;

        parent = class->parent;
        D.25436 = parent->vtable_size;
        D.25437 = (unsigned int) D.25436;
        D.25438 = D.25437 * 4;
        D.25439 = parent->vtable;
        memcpy (vtable, D.25439, D.25438);
        i = 0;
        goto <D.19629>;
        <D.19628>:
        {
          struct MonoClass * parent_interface;
          int interface_offset;

          D.25440 = parent->interfaces_packed;
          i.201 = (unsigned int) i;
          D.25442 = i.201 * 4;
          D.25443 = D.25440 + D.25442;
          parent_interface = *D.25443;
          interface_offset = mono_class_interface_offset (class, parent_interface);
          D.25436 = parent->vtable_size;
          if (D.25436 <= interface_offset) goto <D.25444>; else goto <D.25445>;
          <D.25444>:
          {
            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.19626>;
            <D.19625>:
            D.25446 = interface_offset + j;
            D.25447 = (unsigned int) D.25446;
            D.25448 = D.25447 * 4;
            D.25449 = vtable + D.25448;
            D.25439 = parent->vtable;
            D.25450 = parent_interface_offset + j;
            D.25451 = (unsigned int) D.25450;
            D.25452 = D.25451 * 4;
            D.25453 = D.25439 + D.25452;
            D.25454 = *D.25453;
            *D.25449 = D.25454;
            j = j + 1;
            <D.19626>:
            j.202 = (unsigned int) j;
            D.25456 = parent_interface->method.count;
            if (j.202 < D.25456) goto <D.25457>; else goto <D.19627>;
            <D.25457>:
            D.25458 = class->exception_type;
            if (D.25458 == 0) goto <D.19625>; else goto <D.19627>;
            <D.19627>:
          }
          <D.25445>:
        }
        i = i + 1;
        <D.19629>:
        D.25459 = parent->interface_offsets_count;
        D.25460 = (int) D.25459;
        if (D.25460 > i) goto <D.19628>; else goto <D.19630>;
        <D.19630>:
      }
      <D.25435>:
      <D.25433>:
      D.25461 = mono_class_need_stelemref_method (class);
      if (D.25461 != 0) goto <D.25462>; else goto <D.25463>;
      <D.25462>:
      {
        struct MonoMethod * method;

        method = mono_marshal_get_virtual_stelemref (class);
        D.25464 = method->slot;
        if (D.25464 == 0) goto <D.25465>; else goto <D.25466>;
        <D.25465>:
        D.25467 = (short int) stelemref_slot;
        method->slot = D.25467;
        goto <D.25468>;
        <D.25466>:
        D.25464 = method->slot;
        D.25469 = (int) D.25464;
        D.25470 = D.25469 != stelemref_slot;
        D.25471 = (long int) D.25470;
        D.25472 = __builtin_expect (D.25471, 0);
        if (D.25472 != 0) goto <D.25473>; else goto <D.25474>;
        <D.25473>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "class.c", 4263, "method->slot == stelemref_slot");
        <D.25474>:
        <D.25468>:
        stelemref_slot.203 = (unsigned int) stelemref_slot;
        D.25476 = stelemref_slot.203 * 4;
        D.25477 = vtable + D.25476;
        *D.25477 = method;
      }
      <D.25463>:
      i = 0;
      goto <D.19635>;
      <D.19634>:
      {
        struct MonoMethod * decl;

        i.196 = (unsigned int) i;
        D.25478 = i.196 * 8;
        D.25479 = overrides + D.25478;
        decl = *D.25479;
        D.25482 = decl->klass;
        D.25483 = D.25482->flags;
        D.25484 = D.25483 & 32;
        if (D.25484 != 0) goto <D.25480>; else goto <D.25485>;
        <D.25485>:
        D.25482 = decl->klass;
        D.25486 = D.25482->byval_arg.type;
        if (D.25486 == 19) goto <D.25480>; else goto <D.25487>;
        <D.25487>:
        D.25482 = decl->klass;
        D.25486 = D.25482->byval_arg.type;
        if (D.25486 == 30) goto <D.25480>; else goto <D.25481>;
        <D.25480>:
        {
          int dslot;

          dslot = mono_method_get_vtable_slot (decl);
          if (dslot == -1) goto <D.25488>; else goto <D.25489>;
          <D.25488>:
          mono_class_set_failure (class, 7, 0B);
          return;
          <D.25489>:
          D.25482 = decl->klass;
          D.25490 = mono_class_interface_offset (class, D.25482);
          dslot = D.25490 + dslot;
          dslot.204 = (unsigned int) dslot;
          D.25492 = dslot.204 * 4;
          D.25493 = vtable + D.25492;
          i.205 = (sizetype) i;
          D.25495 = i.205 * 8;
          D.25496 = D.25495 + 4;
          D.25497 = overrides + D.25496;
          D.25498 = *D.25497;
          *D.25493 = D.25498;
          dslot.204 = (unsigned int) dslot;
          D.25492 = dslot.204 * 4;
          D.25493 = vtable + D.25492;
          D.25499 = *D.25493;
          D.25500 = (short int) dslot;
          D.25499->slot = D.25500;
          if (override_map == 0B) goto <D.25501>; else goto <D.25502>;
          <D.25501>:
          override_map = monoeg_g_hash_table_new (mono_aligned_addr_hash, 0B);
          <D.25502>:
          i.205 = (sizetype) i;
          D.25495 = i.205 * 8;
          D.25496 = D.25495 + 4;
          D.25497 = overrides + D.25496;
          D.25498 = *D.25497;
          i.196 = (unsigned int) i;
          D.25478 = i.196 * 8;
          D.25479 = overrides + D.25478;
          D.25503 = *D.25479;
          monoeg_g_hash_table_insert_replace (override_map, D.25503, D.25498, 0);
          D.25504 = mono_security_get_mode ();
          if (D.25504 == 1) goto <D.25505>; else goto <D.25506>;
          <D.25505>:
          dslot.204 = (unsigned int) dslot;
          D.25492 = dslot.204 * 4;
          D.25493 = vtable + D.25492;
          D.25499 = *D.25493;
          mono_security_core_clr_check_override (class, D.25499, decl);
          <D.25506>:
        }
        <D.25481>:
      }
      i = i + 1;
      <D.19635>:
      if (i < onum) goto <D.19634>; else goto <D.19636>;
      <D.19636>:
      {
        void * iter;
        struct MonoMethod * cm;

        try
          {
            iter = 0B;
            virt_methods = 0B;
            goto <D.19640>;
            <D.19639>:
            virt_methods = monoeg_g_slist_prepend (virt_methods, cm);
            <D.19640>:
            cm = mono_class_get_virtual_methods (class, &iter);
            if (cm != 0B) goto <D.19639>; else goto <D.19641>;
            <D.19641>:
            D.25458 = class->exception_type;
            if (D.25458 != 0) goto fail; else goto <D.25507>;
            <D.25507>:
          }
        finally
          {
            iter = {CLOBBER};
          }
      }
      i = 0;
      goto <D.19670>;
      <D.19669>:
      {
        struct MonoClass * parent;
        int ic_offset;
        gboolean interface_is_explicitly_implemented_by_class;
        int im_index;

        parent = class->parent;
        D.25508 = class->interfaces_packed;
        i.196 = (unsigned int) i;
        D.25369 = i.196 * 4;
        D.25509 = D.25508 + D.25369;
        ic = *D.25509;
        ic_offset = mono_class_interface_offset (class, ic);
        mono_class_setup_methods (ic);
        D.25510 = ic->exception_type;
        if (D.25510 != 0) goto fail; else goto <D.25511>;
        <D.25511>:
        if (parent != 0B) goto <D.25512>; else goto <D.25513>;
        <D.25512>:
        {
          int implemented_interfaces_index;

          interface_is_explicitly_implemented_by_class = 0;
          implemented_interfaces_index = 0;
          goto <D.19650>;
          <D.19649>:
          D.25514 = class->interfaces;
          implemented_interfaces_index.206 = (unsigned int) implemented_interfaces_index;
          D.25516 = implemented_interfaces_index.206 * 4;
          D.25517 = D.25514 + D.25516;
          D.25518 = *D.25517;
          if (D.25518 == ic) goto <D.25519>; else goto <D.25520>;
          <D.25519>:
          interface_is_explicitly_implemented_by_class = 1;
          goto <D.19648>;
          <D.25520>:
          implemented_interfaces_index = implemented_interfaces_index + 1;
          <D.19650>:
          D.25521 = class->interface_count;
          D.25522 = (int) D.25521;
          if (D.25522 > implemented_interfaces_index) goto <D.19649>; else goto <D.19648>;
          <D.19648>:
        }
        goto <D.25523>;
        <D.25513>:
        interface_is_explicitly_implemented_by_class = 1;
        <D.25523>:
        im_index = 0;
        goto <D.19667>;
        <D.19666>:
        {
          struct MonoMethod * im;
          int im_slot;
          struct MonoMethod * override_im;

          D.25524 = ic->methods;
          im_index.207 = (unsigned int) im_index;
          D.25526 = im_index.207 * 4;
          D.25527 = D.25524 + D.25526;
          im = *D.25527;
          D.25528 = im->slot;
          D.25529 = (int) D.25528;
          im_slot = D.25529 + ic_offset;
          if (override_map != 0B) goto <D.25531>; else goto <D.25532>;
          <D.25531>:
          iftmp.208 = monoeg_g_hash_table_lookup (override_map, im);
          goto <D.25533>;
          <D.25532>:
          iftmp.208 = 0B;
          <D.25533>:
          override_im = iftmp.208;
          D.25534 = im->flags;
          D.25535 = (int) D.25534;
          D.25536 = D.25535 & 16;
          if (D.25536 != 0) goto <D.25537>; else goto <D.25538>;
          <D.25537>:
          // predicted unlikely by continue predictor.
          goto <D.19654>;
          <D.25538>:
          if (override_im == 0B) goto <D.25539>; else goto <D.25540>;
          <D.25539>:
          {
            int cm_index;
            void * iter;
            struct MonoMethod * cm;

            iter = 0B;
            l = virt_methods;
            goto <D.19659>;
            <D.19658>:
            cm = l->data;
            im_slot.209 = (unsigned int) im_slot;
            D.25542 = im_slot.209 * 4;
            D.25543 = vtable + D.25542;
            D.25544 = *D.25543;
            D.25545 = D.25544 == 0B;
            D.25546 = (int) D.25545;
            D.25547 = check_interface_method_override (class, im, cm, 1, interface_is_explicitly_implemented_by_class, D.25546, security_enabled);
            if (D.25547 != 0) goto <D.25548>; else goto <D.25549>;
            <D.25548>:
            im_slot.209 = (unsigned int) im_slot;
            D.25542 = im_slot.209 * 4;
            D.25543 = vtable + D.25542;
            *D.25543 = cm;
            D.25550 = cm->slot;
            if (D.25550 < 0) goto <D.25551>; else goto <D.25552>;
            <D.25551>:
            D.25553 = (short int) im_slot;
            cm->slot = D.25553;
            <D.25552>:
            <D.25549>:
            D.25458 = class->exception_type;
            if (D.25458 != 0) goto fail; else goto <D.25554>;
            <D.25554>:
            l = l->next;
            <D.19659>:
            if (l != 0B) goto <D.19658>; else goto <D.19660>;
            <D.19660>:
            im_slot.209 = (unsigned int) im_slot;
            D.25542 = im_slot.209 * 4;
            D.25543 = vtable + D.25542;
            D.25544 = *D.25543;
            if (D.25544 == 0B) goto <D.25555>; else goto <D.25556>;
            <D.25555>:
            D.25376 = class->parent;
            if (D.25376 != 0B) goto <D.25557>; else goto <D.25558>;
            <D.25557>:
            {
              struct MonoClass * parent;

              parent = class->parent;
              D.25559 = parent->vtable_size;
              cm_index = D.25559 + -1;
              goto <D.19665>;
              <D.19664>:
              {
                struct MonoMethod * cm;

                D.25560 = parent->vtable;
                cm_index.210 = (unsigned int) cm_index;
                D.25562 = cm_index.210 * 4;
                D.25563 = D.25560 + D.25562;
                cm = *D.25563;
                if (cm != 0B) goto <D.25564>; else goto <D.25565>;
                <D.25564>:
                D.25566 = check_interface_method_override (class, im, cm, 0, 0, 1, security_enabled);
                if (D.25566 != 0) goto <D.25567>; else goto <D.25568>;
                <D.25567>:
                im_slot.209 = (unsigned int) im_slot;
                D.25542 = im_slot.209 * 4;
                D.25543 = vtable + D.25542;
                *D.25543 = cm;
                D.25569 = cm->slot;
                if (D.25569 < 0) goto <D.25570>; else goto <D.25571>;
                <D.25570>:
                D.25553 = (short int) im_slot;
                cm->slot = D.25553;
                <D.25571>:
                goto <D.19663>;
                <D.25568>:
                <D.25565>:
                D.25458 = class->exception_type;
                if (D.25458 != 0) goto fail; else goto <D.25572>;
                <D.25572>:
              }
              cm_index = cm_index + -1;
              <D.19665>:
              if (cm_index >= 0) goto <D.19664>; else goto <D.19663>;
              <D.19663>:
            }
            <D.25558>:
            <D.25556>:
          }
          goto <D.25573>;
          <D.25540>:
          im_slot.209 = (unsigned int) im_slot;
          D.25542 = im_slot.209 * 4;
          D.25543 = vtable + D.25542;
          D.25544 = *D.25543;
          D.25574 = D.25544 != override_im;
          D.25575 = (long int) D.25574;
          D.25576 = __builtin_expect (D.25575, 0);
          if (D.25576 != 0) goto <D.25577>; else goto <D.25578>;
          <D.25577>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "class.c", 4399, "vtable [im_slot] == override_im");
          <D.25578>:
          <D.25573>:
        }
        <D.19654>:
        im_index = im_index + 1;
        <D.19667>:
        im_index.211 = (unsigned int) im_index;
        D.25580 = ic->method.count;
        if (im_index.211 < D.25580) goto <D.19666>; else goto <D.19668>;
        <D.19668>:
      }
      i = i + 1;
      <D.19670>:
      D.25581 = class->interface_offsets_count;
      D.25582 = (int) D.25581;
      if (D.25582 > i) goto <D.19669>; else goto <D.19671>;
      <D.19671>:
      D.25583 = class->flags;
      D.25584 = D.25583 & 128;
      if (D.25584 == 0) goto <D.25585>; else goto <D.25586>;
      <D.25585>:
      i = 0;
      goto <D.19681>;
      <D.19680>:
      {
        int ic_offset;
        int im_index;

        D.25508 = class->interfaces_packed;
        i.196 = (unsigned int) i;
        D.25369 = i.196 * 4;
        D.25509 = D.25508 + D.25369;
        ic = *D.25509;
        ic_offset = mono_class_interface_offset (class, ic);
        im_index = 0;
        goto <D.19678>;
        <D.19677>:
        {
          struct MonoMethod * im;
          int im_slot;

          D.25524 = ic->methods;
          im_index.212 = (unsigned int) im_index;
          D.25588 = im_index.212 * 4;
          D.25589 = D.25524 + D.25588;
          im = *D.25589;
          D.25590 = im->slot;
          D.25591 = (int) D.25590;
          im_slot = D.25591 + ic_offset;
          D.25592 = im->flags;
          D.25593 = (int) D.25592;
          D.25594 = D.25593 & 16;
          if (D.25594 != 0) goto <D.25595>; else goto <D.25596>;
          <D.25595>:
          // predicted unlikely by continue predictor.
          goto <D.19676>;
          <D.25596>:
          im_slot.213 = (unsigned int) im_slot;
          D.25598 = im_slot.213 * 4;
          D.25599 = vtable + D.25598;
          D.25600 = *D.25599;
          if (D.25600 == 0B) goto <D.25601>; else goto <D.25602>;
          <D.25601>:
          print_unimplemented_interface_method_info (class, ic, im, im_slot, overrides, onum);
          goto fail;
          <D.25602>:
        }
        <D.19676>:
        im_index = im_index + 1;
        <D.19678>:
        im_index.214 = (unsigned int) im_index;
        D.25580 = ic->method.count;
        if (im_index.214 < D.25580) goto <D.19677>; else goto <D.19679>;
        <D.19679>:
      }
      i = i + 1;
      <D.19681>:
      D.25581 = class->interface_offsets_count;
      D.25582 = (int) D.25581;
      if (D.25582 > i) goto <D.19680>; else goto <D.19682>;
      <D.19682>:
      <D.25586>:
      class_iter = 0B;
      l = virt_methods;
      goto <D.19706>;
      <D.19705>:
      cm = l->data;
      D.25604 = cm->flags;
      D.25605 = (int) D.25604;
      D.25606 = D.25605 & 256;
      if (D.25606 == 0) goto <D.25607>; else goto <D.25608>;
      <D.25607>:
      {
        int slot;

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

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

                cmsig = mono_method_signature (cm);
                m1sig = mono_method_signature (m1);
                D.25609 = cmsig == 0B;
                D.25610 = m1sig == 0B;
                D.25611 = D.25609 | D.25610;
                if (D.25611 != 0) goto <D.25612>; else goto <D.25613>;
                <D.25612>:
                mono_class_set_failure (class, 7, 0B);
                return;
                <D.25613>:
                {
                  size_t __s1_len;
                  size_t __s2_len;

                  D.25614 = m1->name;
                  D.25615 = cm->name;
                  D.19696 = __builtin_strcmp (D.25615, D.25614);
                }
                if (D.19696 == 0) goto <D.25616>; else goto <D.25617>;
                <D.25616>:
                D.25618 = mono_metadata_signature_equal (cmsig, m1sig);
                if (D.25618 != 0) goto <D.25619>; else goto <D.25620>;
                <D.25619>:
                if (security_enabled != 0) goto <D.25621>; else goto <D.25622>;
                <D.25621>:
                D.25623 = m1->flags;
                D.25624 = (int) D.25623;
                D.25625 = D.25624 & 16384;
                if (D.25625 != 0) goto <D.25626>; else goto <D.25627>;
                <D.25626>:
                mono_secman_inheritancedemand_method (cm, m1);
                <D.25627>:
                <D.25622>:
                D.25628 = mono_security_get_mode ();
                if (D.25628 == 1) goto <D.25629>; else goto <D.25630>;
                <D.25629>:
                mono_security_core_clr_check_override (class, cm, m1);
                <D.25630>:
                slot = mono_method_get_vtable_slot (m1);
                if (slot == -1) goto fail; else goto <D.25631>;
                <D.25631>:
                D.25632 = is_wcf_hack_disabled ();
                if (D.25632 != 0) goto <D.25633>; else goto <D.25634>;
                <D.25633>:
                D.25635 = mono_method_can_access_method_full (cm, m1, 0B);
                if (D.25635 == 0) goto <D.25636>; else goto <D.25637>;
                <D.25636>:
                {
                  char * body_name;
                  char * decl_name;

                  body_name = mono_method_full_name (cm, 1);
                  decl_name = mono_method_full_name (m1, 1);
                  D.25638 = monoeg_g_strdup_printf ("Method %s overrides method \'%s\' which is not accessible", body_name, decl_name);
                  mono_class_set_failure (class, 7, D.25638);
                  monoeg_g_free (body_name);
                  monoeg_g_free (decl_name);
                  goto fail;
                }
                <D.25637>:
                <D.25634>:
                D.25639 = cm->slot;
                D.25640 = (int) D.25639;
                D.25641 = D.25640 >= max_vtsize;
                D.25642 = (long int) D.25641;
                D.25643 = __builtin_expect (D.25642, 0);
                if (D.25643 != 0) goto <D.25644>; else goto <D.25645>;
                <D.25644>:
                monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "class.c", 4484, "cm->slot < max_vtsize");
                <D.25645>:
                if (override_map == 0B) goto <D.25646>; else goto <D.25647>;
                <D.25646>:
                override_map = monoeg_g_hash_table_new (mono_aligned_addr_hash, 0B);
                <D.25647>:
                monoeg_g_hash_table_insert_replace (override_map, m1, cm, 0);
                goto <D.19699>;
                <D.25620>:
                <D.25617>:
              }
              <D.19701>:
              m1 = mono_class_get_virtual_methods (k, &k_iter);
              if (m1 != 0B) goto <D.19700>; else goto <D.19699>;
              <D.19699>:
              D.25648 = k->exception_type;
              if (D.25648 != 0) goto fail; else goto <D.25649>;
              <D.25649>:
              if (slot >= 0) goto <D.19702>; else goto <D.25650>;
              <D.25650>:
            }
          finally
            {
              k_iter = {CLOBBER};
            }
        }
        k = k->parent;
        <D.19704>:
        if (k != 0B) goto <D.19703>; else goto <D.19702>;
        <D.19702>:
        if (slot >= 0) goto <D.25651>; else goto <D.25652>;
        <D.25651>:
        D.25653 = (short int) slot;
        cm->slot = D.25653;
        <D.25652>:
      }
      <D.25608>:
      D.25604 = cm->flags;
      D.25654 = (unsigned int) D.25604;
      D.25655 = D.25654 & 288;
      if (D.25655 == 256) goto <D.25656>; else goto <D.25657>;
      <D.25656>:
      D.25639 = cm->slot;
      if (D.25639 >= 0) goto <D.25658>; else goto <D.25659>;
      <D.25658>:
      cm->slot = -1;
      <D.25659>:
      <D.25657>:
      D.25639 = cm->slot;
      if (D.25639 < 0) goto <D.25660>; else goto <D.25661>;
      <D.25660>:
      cur_slot.215 = cur_slot;
      cur_slot = cur_slot.215 + 1;
      D.25663 = (short int) cur_slot.215;
      cm->slot = D.25663;
      <D.25661>:
      D.25604 = cm->flags;
      D.25605 = (int) D.25604;
      D.25664 = D.25605 & 1024;
      if (D.25664 == 0) goto <D.25665>; else goto <D.25666>;
      <D.25665>:
      D.25639 = cm->slot;
      D.25667 = (unsigned int) D.25639;
      D.25668 = D.25667 * 4;
      D.25669 = vtable + D.25668;
      *D.25669 = cm;
      <D.25666>:
      l = l->next;
      <D.19706>:
      if (l != 0B) goto <D.19705>; else goto <D.19707>;
      <D.19707>:
      i = 0;
      goto <D.19710>;
      <D.19709>:
      {
        struct MonoMethod * decl;

        i.196 = (unsigned int) i;
        D.25478 = i.196 * 8;
        D.25479 = overrides + D.25478;
        decl = *D.25479;
        D.25670 = decl->klass;
        D.25671 = D.25670->flags;
        D.25672 = D.25671 & 32;
        if (D.25672 == 0) goto <D.25673>; else goto <D.25674>;
        <D.25673>:
        D.25670 = decl->klass;
        D.25675 = D.25670->byval_arg.type;
        if (D.25675 != 19) goto <D.25676>; else goto <D.25677>;
        <D.25676>:
        D.25670 = decl->klass;
        D.25675 = D.25670->byval_arg.type;
        if (D.25675 != 30) goto <D.25678>; else goto <D.25679>;
        <D.25678>:
        D.25680 = decl->slot;
        D.25681 = D.25680 == -1;
        D.25682 = (long int) D.25681;
        D.25683 = __builtin_expect (D.25682, 0);
        if (D.25683 != 0) goto <D.25684>; else goto <D.25685>;
        <D.25684>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "class.c", 4519, "decl->slot != -1");
        <D.25685>:
        D.25680 = decl->slot;
        D.25686 = (unsigned int) D.25680;
        D.25687 = D.25686 * 4;
        D.25688 = vtable + D.25687;
        i.205 = (sizetype) i;
        D.25495 = i.205 * 8;
        D.25496 = D.25495 + 4;
        D.25497 = overrides + D.25496;
        D.25498 = *D.25497;
        *D.25688 = D.25498;
        i.205 = (sizetype) i;
        D.25495 = i.205 * 8;
        D.25496 = D.25495 + 4;
        D.25497 = overrides + D.25496;
        D.25498 = *D.25497;
        D.25680 = decl->slot;
        D.25498->slot = D.25680;
        if (override_map == 0B) goto <D.25689>; else goto <D.25690>;
        <D.25689>:
        override_map = monoeg_g_hash_table_new (mono_aligned_addr_hash, 0B);
        <D.25690>:
        i.205 = (sizetype) i;
        D.25495 = i.205 * 8;
        D.25496 = D.25495 + 4;
        D.25497 = overrides + D.25496;
        D.25498 = *D.25497;
        monoeg_g_hash_table_insert_replace (override_map, decl, D.25498, 0);
        D.25691 = mono_security_get_mode ();
        if (D.25691 == 1) goto <D.25692>; else goto <D.25693>;
        <D.25692>:
        D.25680 = decl->slot;
        D.25686 = (unsigned int) D.25680;
        D.25687 = D.25686 * 4;
        D.25688 = vtable + D.25687;
        D.25694 = *D.25688;
        mono_security_core_clr_check_override (class, D.25694, decl);
        <D.25693>:
        <D.25679>:
        <D.25677>:
        <D.25674>:
      }
      i = i + 1;
      <D.19710>:
      if (i < onum) goto <D.19709>; else goto <D.19711>;
      <D.19711>:
      if (override_map != 0B) goto <D.25695>; else goto <D.25696>;
      <D.25695>:
      {
        struct MonoMethod * cm;

        i = 0;
        goto <D.19714>;
        <D.19713>:
        i.196 = (unsigned int) i;
        D.25369 = i.196 * 4;
        D.25697 = vtable + D.25369;
        D.25698 = *D.25697;
        if (D.25698 != 0B) goto <D.25699>; else goto <D.25700>;
        <D.25699>:
        i.196 = (unsigned int) i;
        D.25369 = i.196 * 4;
        D.25697 = vtable + D.25369;
        D.25698 = *D.25697;
        cm = monoeg_g_hash_table_lookup (override_map, D.25698);
        if (cm != 0B) goto <D.25701>; else goto <D.25702>;
        <D.25701>:
        i.196 = (unsigned int) i;
        D.25369 = i.196 * 4;
        D.25697 = vtable + D.25369;
        *D.25697 = cm;
        <D.25702>:
        <D.25700>:
        i = i + 1;
        <D.19714>:
        if (i < max_vtsize) goto <D.19713>; else goto <D.19715>;
        <D.19715>:
        monoeg_g_hash_table_destroy (override_map);
        override_map = 0B;
      }
      <D.25696>:
      monoeg_g_slist_free (virt_methods);
      virt_methods = 0B;
      D.25583 = class->flags;
      D.25584 = D.25583 & 128;
      if (D.25584 == 0) goto <D.25703>; else goto <D.25704>;
      <D.25703>:
      i = 0;
      goto <D.19719>;
      <D.19718>:
      i.196 = (unsigned int) i;
      D.25369 = i.196 * 4;
      D.25697 = vtable + D.25369;
      D.25698 = *D.25697;
      if (D.25698 == 0B) goto <D.25705>; else goto <D.25707>;
      <D.25707>:
      i.196 = (unsigned int) i;
      D.25369 = i.196 * 4;
      D.25697 = vtable + D.25369;
      D.25698 = *D.25697;
      D.25708 = D.25698->flags;
      D.25709 = (int) D.25708;
      D.25710 = D.25709 & 1040;
      if (D.25710 != 0) goto <D.25705>; else goto <D.25706>;
      <D.25705>:
      {
        char * type_name;
        char * method_name;

        type_name = mono_type_get_full_name (class);
        i.196 = (unsigned int) i;
        D.25369 = i.196 * 4;
        D.25697 = vtable + D.25369;
        D.25698 = *D.25697;
        if (D.25698 != 0B) goto <D.25712>; else goto <D.25713>;
        <D.25712>:
        i.196 = (unsigned int) i;
        D.25369 = i.196 * 4;
        D.25697 = vtable + D.25369;
        D.25698 = *D.25697;
        iftmp.216 = mono_method_full_name (D.25698, 1);
        goto <D.25714>;
        <D.25713>:
        iftmp.216 = monoeg_strdup ("none");
        <D.25714>:
        method_name = iftmp.216;
        D.25715 = 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.25715);
        monoeg_g_free (type_name);
        monoeg_g_free (method_name);
        return;
      }
      <D.25706>:
      i = i + 1;
      <D.19719>:
      if (i < cur_slot) goto <D.19718>; else goto <D.19720>;
      <D.19720>:
      <D.25704>:
      D.25394 = class->generic_class;
      if (D.25394 != 0B) goto <D.25716>; else goto <D.25717>;
      <D.25716>:
      {
        struct MonoClass * gklass;

        D.25394 = class->generic_class;
        gklass = D.25394->container_class;
        mono_class_init (gklass);
        D.25718 = gklass->vtable_size;
        D.25719 = MAX_EXPR <D.25718, cur_slot>;
        class->vtable_size = D.25719;
      }
      goto <D.25720>;
      <D.25717>:
      D.25721 = class->vtable_size;
      if (D.25721 != 0) goto <D.25722>; else goto <D.25723>;
      <D.25722>:
      D.25721 = class->vtable_size;
      D.25724 = D.25721 != cur_slot;
      D.25725 = (long int) D.25724;
      D.25726 = __builtin_expect (D.25725, 0);
      if (D.25726 != 0) goto <D.25727>; else goto <D.25728>;
      <D.25727>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "class.c", 4580, "cur_slot == class->vtable_size");
      <D.25728>:
      <D.25723>:
      class->vtable_size = cur_slot;
      <D.25720>:
      D.25376 = class->parent;
      if (D.25376 != 0B) goto <D.25731>; else goto <D.25729>;
      <D.25731>:
      D.25376 = class->parent;
      D.25383 = D.25376->vtable_size;
      D.25721 = class->vtable_size;
      if (D.25383 == D.25721) goto <D.25732>; else goto <D.25729>;
      <D.25732>:
      D.25721 = class->vtable_size;
      D.25733 = (unsigned int) D.25721;
      D.25734 = D.25733 * 4;
      D.25376 = class->parent;
      D.25735 = D.25376->vtable;
      D.25736 = memcmp (D.25735, vtable, D.25734);
      if (D.25736 == 0) goto <D.25737>; else goto <D.25729>;
      <D.25737>:
      mono_memory_barrier ();
      D.25376 = class->parent;
      D.25735 = D.25376->vtable;
      class->vtable = D.25735;
      goto <D.25730>;
      <D.25729>:
      {
        struct MonoMethod * * tmp;

        D.25721 = class->vtable_size;
        D.25733 = (unsigned int) D.25721;
        D.25734 = D.25733 * 4;
        D.25738 = (int) D.25734;
        tmp = mono_class_alloc0 (class, D.25738);
        D.25721 = class->vtable_size;
        D.25733 = (unsigned int) D.25721;
        D.25734 = D.25733 * 4;
        memcpy (tmp, vtable, D.25734);
        mono_memory_barrier ();
        class->vtable = tmp;
      }
      <D.25730>:
      mono_print_vtable.217 = mono_print_vtable;
      if (mono_print_vtable.217 != 0) goto <D.25740>; else goto <D.25741>;
      <D.25740>:
      {
        int icount;

        icount = 0;
        print_implemented_interfaces (class);
        i = 0;
        goto <D.19725>;
        <D.19724>:
        D.25393 = class->max_interface_id;
        D.25742 = (int) D.25393;
        if (D.25742 >= i) goto <D.25743>; else goto <D.25744>;
        <D.25743>:
        D.25745 = class->interface_bitmap;
        D.25746 = i >> 3;
        D.25747 = (sizetype) D.25746;
        D.25748 = D.25745 + D.25747;
        D.25749 = *D.25748;
        D.25750 = (int) D.25749;
        D.25751 = i & 7;
        D.25752 = D.25750 >> D.25751;
        D.25753 = D.25752 & 1;
        if (D.25753 != 0) goto <D.25754>; else goto <D.25755>;
        <D.25754>:
        icount = icount + 1;
        <D.25755>:
        <D.25744>:
        i = i + 1;
        <D.19725>:
        if (i <= max_iid) goto <D.19724>; else goto <D.19726>;
        <D.19726>:
        D.25721 = class->vtable_size;
        D.25756 = &class->byval_arg;
        D.25757 = mono_type_full_name (D.25756);
        printf ("VTable %s (vtable entries = %d, interfaces = %d)\n", D.25757, D.25721, icount);
        i = 0;
        goto <D.19729>;
        <D.19728>:
        {
          struct MonoMethod * cm;

          i.196 = (unsigned int) i;
          D.25369 = i.196 * 4;
          D.25697 = vtable + D.25369;
          cm = *D.25697;
          if (cm != 0B) goto <D.25758>; else goto <D.25759>;
          <D.25758>:
          D.25760 = mono_method_full_name (cm, 1);
          D.25761 = cm->slot;
          D.25762 = (int) D.25761;
          printf ("  slot assigned: %03d, slot index: %03d %s\n", i, D.25762, D.25760);
          <D.25759>:
        }
        i = i + 1;
        <D.19729>:
        if (i < cur_slot) goto <D.19728>; else goto <D.19730>;
        <D.19730>:
        if (icount != 0) goto <D.25763>; else goto <D.25764>;
        <D.25763>:
        D.25765 = class->name;
        D.25766 = class->name_space;
        printf ("Interfaces %s.%s (max_iid = %d)\n", D.25766, D.25765, max_iid);
        i = 0;
        goto <D.19732>;
        <D.19731>:
        D.25514 = class->interfaces;
        i.196 = (unsigned int) i;
        D.25369 = i.196 * 4;
        D.25767 = D.25514 + D.25369;
        ic = *D.25767;
        D.25768 = &ic->byval_arg;
        D.25769 = mono_type_full_name (D.25768);
        D.25770 = ic->interface_id;
        D.25771 = (int) D.25770;
        D.25772 = count_virtual_methods (ic);
        D.25773 = mono_class_interface_offset (class, ic);
        printf ("  slot offset: %03d, method count: %03d, iid: %03d %s\n", D.25773, D.25772, D.25771, D.25769);
        i = i + 1;
        <D.19732>:
        D.25521 = class->interface_count;
        D.25522 = (int) D.25521;
        if (D.25522 > i) goto <D.19731>; else goto <D.19733>;
        <D.19733>:
        k = class->parent;
        goto <D.19738>;
        <D.19737>:
        i = 0;
        goto <D.19735>;
        <D.19734>:
        D.25774 = k->interfaces;
        i.196 = (unsigned int) i;
        D.25369 = i.196 * 4;
        D.25775 = D.25774 + D.25369;
        ic = *D.25775;
        D.25768 = &ic->byval_arg;
        D.25776 = mono_type_full_name (D.25768);
        D.25770 = ic->interface_id;
        D.25771 = (int) D.25770;
        D.25777 = count_virtual_methods (ic);
        D.25778 = mono_class_interface_offset (class, ic);
        printf ("  parent slot offset: %03d, method count: %03d, iid: %03d %s\n", D.25778, D.25777, D.25771, D.25776);
        i = i + 1;
        <D.19735>:
        D.25779 = k->interface_count;
        D.25780 = (int) D.25779;
        if (D.25780 > i) goto <D.19734>; else goto <D.19736>;
        <D.19736>:
        k = k->parent;
        <D.19738>:
        if (k != 0B) goto <D.19737>; else goto <D.19739>;
        <D.19739>:
        <D.25764>:
      }
      <D.25741>:
      return;
      fail:
      {
        char * name;

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


verify_class_overrides (struct MonoClass * class, struct MonoMethod * * overrides, int onum)
{
  unsigned int i.218;
  unsigned int D.25797;
  struct MonoMethod * * D.25798;
  sizetype i.219;
  sizetype D.25800;
  sizetype D.25801;
  struct MonoMethod * * D.25802;
  struct MonoClass * D.25803;
  struct MonoClass * D.25804;
  struct MonoClass * D.25805;
  gchar * D.25808;
  gboolean D.25809;
  short unsigned int D.25810;
  unsigned int D.25811;
  unsigned int D.25812;
  int D.25815;
  int D.25816;
  gchar * D.25819;
  gchar * D.25821;
  short unsigned int D.25822;
  unsigned int D.25823;
  unsigned int D.25824;
  gchar * D.25829;
  gchar * D.25831;
  struct MonoClass * D.25832;
  int D.25833;
  gchar * D.25836;
  int D.25837;
  int D.25840;
  gchar * D.25843;
  int i;

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

    i.218 = (unsigned int) i;
    D.25797 = i.218 * 8;
    D.25798 = overrides + D.25797;
    decl = *D.25798;
    i.219 = (sizetype) i;
    D.25800 = i.219 * 8;
    D.25801 = D.25800 + 4;
    D.25802 = overrides + D.25801;
    body = *D.25802;
    D.25803 = body->klass;
    D.25804 = mono_class_get_generic_type_definition (D.25803);
    D.25805 = mono_class_get_generic_type_definition (class);
    if (D.25804 != D.25805) goto <D.25806>; else goto <D.25807>;
    <D.25806>:
    D.25808 = monoeg_strdup ("Method belongs to a different class than the declared one");
    mono_class_set_failure (class, 7, D.25808);
    D.25809 = 0;
    return D.25809;
    <D.25807>:
    D.25810 = body->flags;
    D.25811 = (unsigned int) D.25810;
    D.25812 = D.25811 & 80;
    if (D.25812 != 64) goto <D.25813>; else goto <D.25814>;
    <D.25813>:
    D.25810 = body->flags;
    D.25815 = (int) D.25810;
    D.25816 = D.25815 & 16;
    if (D.25816 != 0) goto <D.25817>; else goto <D.25818>;
    <D.25817>:
    D.25819 = monoeg_strdup ("Method must not be static to override a base type");
    mono_class_set_failure (class, 7, D.25819);
    goto <D.25820>;
    <D.25818>:
    D.25821 = monoeg_strdup ("Method must be virtual to override a base type");
    mono_class_set_failure (class, 7, D.25821);
    <D.25820>:
    D.25809 = 0;
    return D.25809;
    <D.25814>:
    D.25822 = decl->flags;
    D.25823 = (unsigned int) D.25822;
    D.25824 = D.25823 & 80;
    if (D.25824 != 64) goto <D.25825>; else goto <D.25826>;
    <D.25825>:
    D.25810 = body->flags;
    D.25815 = (int) D.25810;
    D.25816 = D.25815 & 16;
    if (D.25816 != 0) goto <D.25827>; else goto <D.25828>;
    <D.25827>:
    D.25829 = monoeg_strdup ("Cannot override a static method in a base type");
    mono_class_set_failure (class, 7, D.25829);
    goto <D.25830>;
    <D.25828>:
    D.25831 = monoeg_strdup ("Cannot override a non virtual method in a base type");
    mono_class_set_failure (class, 7, D.25831);
    <D.25830>:
    D.25809 = 0;
    return D.25809;
    <D.25826>:
    D.25832 = decl->klass;
    D.25833 = mono_class_is_assignable_from_slow (D.25832, class);
    if (D.25833 == 0) goto <D.25834>; else goto <D.25835>;
    <D.25834>:
    D.25836 = monoeg_strdup ("Method overrides a class or interface that extended or implemented by this type");
    mono_class_set_failure (class, 7, D.25836);
    D.25809 = 0;
    return D.25809;
    <D.25835>:
    body = mono_method_get_method_definition (body);
    decl = mono_method_get_method_definition (decl);
    D.25837 = is_wcf_hack_disabled ();
    if (D.25837 != 0) goto <D.25838>; else goto <D.25839>;
    <D.25838>:
    D.25840 = mono_method_can_access_method_full (body, decl, 0B);
    if (D.25840 == 0) goto <D.25841>; else goto <D.25842>;
    <D.25841>:
    {
      char * body_name;
      char * decl_name;

      body_name = mono_method_full_name (body, 1);
      decl_name = mono_method_full_name (decl, 1);
      D.25843 = monoeg_g_strdup_printf ("Method %s overrides method \'%s\' which is not accessible", body_name, decl_name);
      mono_class_set_failure (class, 7, D.25843);
      monoeg_g_free (body_name);
      monoeg_g_free (decl_name);
      D.25809 = 0;
      return D.25809;
    }
    <D.25842>:
    <D.25839>:
  }
  i = i + 1;
  <D.19575>:
  if (i < onum) goto <D.19574>; else goto <D.19576>;
  <D.19576>:
  D.25809 = 1;
  return D.25809;
}


mono_method_get_method_definition (struct MonoMethod * method)
{
  unsigned char D.25845;
  unsigned char D.25846;
  struct MonoMethod * D.25847;

  goto <D.19562>;
  <D.19561>:
  method = MEM[(struct MonoMethodInflated *)method].declaring;
  <D.19562>:
  D.25845 = BIT_FIELD_REF <*method, 8, 168>;
  D.25846 = D.25845 & 16;
  if (D.25846 != 0) goto <D.19561>; else goto <D.19563>;
  <D.19563>:
  D.25847 = method;
  return D.25847;
}


mono_class_need_stelemref_method (struct MonoClass * class)
{
  gboolean D.25849;
  int iftmp.220;
  unsigned char D.25853;
  struct MonoClass * D.25855;
  struct MonoType * D.25856;
  int D.25857;

  D.25853 = class->rank;
  if (D.25853 == 1) goto <D.25854>; else goto <D.25851>;
  <D.25854>:
  D.25855 = class->element_class;
  D.25856 = &D.25855->byval_arg;
  D.25857 = mono_type_is_reference (D.25856);
  if (D.25857 != 0) goto <D.25858>; else goto <D.25851>;
  <D.25858>:
  iftmp.220 = 1;
  goto <D.25852>;
  <D.25851>:
  iftmp.220 = 0;
  <D.25852>:
  D.25849 = iftmp.220;
  return D.25849;
}


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)
{
  int D.19467;
  const char * D.25860;
  const char * D.25861;
  short unsigned int D.25864;
  int D.25865;
  int D.25866;
  gboolean D.25869;
  int D.25876;
  _Bool D.25880;
  _Bool D.25881;
  _Bool D.25882;
  gchar * D.25885;
  int D.25886;
  short unsigned int D.25891;
  int D.25892;
  int D.25893;
  <unnamed type> D.25896;
  int D.25899;
  int D.25902;
  gchar * D.25905;
  struct MonoClass * D.25908;
  unsigned char D.25909;
  gchar * D.25914;
  int D.25915;
  struct MonoImage * D.25918;
  struct MonoImage * D.25919;
  int D.19482;
  int iftmp.221;
  int D.19481;
  const char[27] * D.25928;
  unsigned char D.25929;
  int D.25930;
  unsigned char D.25931;
  int D.25932;
  _Bool D.25933;
  _Bool D.25934;
  _Bool D.25935;
  const unsigned char * D.25938;
  unsigned char D.25939;
  int D.25940;
  const unsigned char * D.25941;
  unsigned char D.25942;
  int D.25943;
  _Bool D.25944;
  _Bool D.25945;
  const unsigned char * D.25948;
  unsigned char D.25949;
  int D.25950;
  const unsigned char * D.25951;
  unsigned char D.25952;
  int D.25953;
  _Bool D.25954;
  _Bool D.25955;
  const unsigned char * D.25958;
  unsigned char D.25959;
  int D.25960;
  const unsigned char * D.25961;
  unsigned char D.25962;
  int D.25963;
  int D.19491;
  int iftmp.222;
  int D.19490;
  const char[14] * D.25971;
  unsigned char D.25972;
  int D.25973;
  unsigned char D.25974;
  int D.25975;
  _Bool D.25976;
  _Bool D.25977;
  _Bool D.25978;
  const unsigned char * D.25981;
  unsigned char D.25982;
  int D.25983;
  const unsigned char * D.25984;
  unsigned char D.25985;
  int D.25986;
  _Bool D.25987;
  _Bool D.25988;
  const unsigned char * D.25991;
  unsigned char D.25992;
  int D.25993;
  const unsigned char * D.25994;
  unsigned char D.25995;
  int D.25996;
  _Bool D.25997;
  _Bool D.25998;
  const unsigned char * D.26001;
  unsigned char D.26002;
  int D.26003;
  const unsigned char * D.26004;
  unsigned char D.26005;
  int D.26006;
  int D.19500;
  int iftmp.223;
  int D.19499;
  const char[14] * D.26012;
  unsigned char D.26013;
  int D.26014;
  unsigned char D.26015;
  int D.26016;
  _Bool D.26017;
  _Bool D.26018;
  _Bool D.26019;
  const unsigned char * D.26022;
  unsigned char D.26023;
  int D.26024;
  const unsigned char * D.26025;
  unsigned char D.26026;
  int D.26027;
  _Bool D.26028;
  _Bool D.26029;
  const unsigned char * D.26032;
  unsigned char D.26033;
  int D.26034;
  const unsigned char * D.26035;
  unsigned char D.26036;
  int D.26037;
  _Bool D.26038;
  _Bool D.26039;
  const unsigned char * D.26042;
  unsigned char D.26043;
  int D.26044;
  const unsigned char * D.26045;
  unsigned char D.26046;
  int D.26047;
  int D.19509;
  int iftmp.224;
  int D.19508;
  const char[8] * D.26053;
  unsigned char D.26054;
  int D.26055;
  unsigned char D.26056;
  int D.26057;
  _Bool D.26058;
  _Bool D.26059;
  _Bool D.26060;
  const unsigned char * D.26063;
  unsigned char D.26064;
  int D.26065;
  const unsigned char * D.26066;
  unsigned char D.26067;
  int D.26068;
  _Bool D.26069;
  _Bool D.26070;
  const unsigned char * D.26073;
  unsigned char D.26074;
  int D.26075;
  const unsigned char * D.26076;
  unsigned char D.26077;
  int D.26078;
  _Bool D.26079;
  _Bool D.26080;
  const unsigned char * D.26083;
  unsigned char D.26084;
  int D.26085;
  const unsigned char * D.26086;
  unsigned char D.26087;
  int D.26088;
  int D.19518;
  int iftmp.225;
  int D.19517;
  const char[16] * D.26094;
  unsigned char D.26095;
  int D.26096;
  unsigned char D.26097;
  int D.26098;
  _Bool D.26099;
  _Bool D.26100;
  _Bool D.26101;
  const unsigned char * D.26104;
  unsigned char D.26105;
  int D.26106;
  const unsigned char * D.26107;
  unsigned char D.26108;
  int D.26109;
  _Bool D.26110;
  _Bool D.26111;
  const unsigned char * D.26114;
  unsigned char D.26115;
  int D.26116;
  const unsigned char * D.26117;
  unsigned char D.26118;
  int D.26119;
  _Bool D.26120;
  _Bool D.26121;
  const unsigned char * D.26124;
  unsigned char D.26125;
  int D.26126;
  const unsigned char * D.26127;
  unsigned char D.26128;
  int D.26129;
  int D.19527;
  int iftmp.226;
  int D.19526;
  const char[22] * D.26135;
  unsigned char D.26136;
  int D.26137;
  unsigned char D.26138;
  int D.26139;
  _Bool D.26140;
  _Bool D.26141;
  _Bool D.26142;
  const unsigned char * D.26145;
  unsigned char D.26146;
  int D.26147;
  const unsigned char * D.26148;
  unsigned char D.26149;
  int D.26150;
  _Bool D.26151;
  _Bool D.26152;
  const unsigned char * D.26155;
  unsigned char D.26156;
  int D.26157;
  const unsigned char * D.26158;
  unsigned char D.26159;
  int D.26160;
  _Bool D.26161;
  _Bool D.26162;
  const unsigned char * D.26165;
  unsigned char D.26166;
  int D.26167;
  const unsigned char * D.26168;
  unsigned char D.26169;
  int D.26170;
  unsigned int D.26174;
  char D.26175;
  char * D.26178;
  unsigned int D.26181;
  int D.19536;
  <unnamed type> D.26190;
  int D.26193;
  int D.26196;
  gchar * D.26199;
  struct MonoMethodSignature * cmsig;
  struct MonoMethodSignature * imsig;

  {
    size_t __s1_len;
    size_t __s2_len;

    D.25860 = cm->name;
    D.25861 = im->name;
    D.19467 = __builtin_strcmp (D.25861, D.25860);
  }
  if (D.19467 == 0) goto <D.25862>; else goto <D.25863>;
  <D.25862>:
  D.25864 = cm->flags;
  D.25865 = (int) D.25864;
  D.25866 = D.25865 & 6;
  if (D.25866 == 0) goto <D.25867>; else goto <D.25868>;
  <D.25867>:
  D.25869 = 0;
  return D.25869;
  <D.25868>:
  if (slot_is_empty == 0) goto <D.25870>; else goto <D.25871>;
  <D.25870>:
  if (require_newslot != 0) goto <D.25872>; else goto <D.25873>;
  <D.25872>:
  if (interface_is_explicitly_implemented_by_class == 0) goto <D.25874>; else goto <D.25875>;
  <D.25874>:
  D.25869 = 0;
  return D.25869;
  <D.25875>:
  D.25864 = cm->flags;
  D.25865 = (int) D.25864;
  D.25876 = D.25865 & 256;
  if (D.25876 == 0) goto <D.25877>; else goto <D.25878>;
  <D.25877>:
  D.25869 = 0;
  return D.25869;
  <D.25878>:
  goto <D.25879>;
  <D.25873>:
  <D.25879>:
  <D.25871>:
  cmsig = mono_method_signature (cm);
  imsig = mono_method_signature (im);
  D.25880 = cmsig == 0B;
  D.25881 = imsig == 0B;
  D.25882 = D.25880 | D.25881;
  if (D.25882 != 0) goto <D.25883>; else goto <D.25884>;
  <D.25883>:
  D.25885 = monoeg_strdup ("Could not resolve the signature of a virtual method");
  mono_class_set_failure (class, 7, D.25885);
  D.25869 = 0;
  return D.25869;
  <D.25884>:
  D.25886 = mono_metadata_signature_equal (cmsig, imsig);
  if (D.25886 == 0) goto <D.25887>; else goto <D.25888>;
  <D.25887>:
  D.25869 = 0;
  return D.25869;
  <D.25888>:
  if (security_enabled != 0) goto <D.25889>; else goto <D.25890>;
  <D.25889>:
  D.25891 = im->flags;
  D.25892 = (int) D.25891;
  D.25893 = D.25892 & 16384;
  if (D.25893 != 0) goto <D.25894>; else goto <D.25895>;
  <D.25894>:
  mono_secman_inheritancedemand_method (cm, im);
  <D.25895>:
  <D.25890>:
  D.25896 = mono_security_get_mode ();
  if (D.25896 == 1) goto <D.25897>; else goto <D.25898>;
  <D.25897>:
  mono_security_core_clr_check_override (class, cm, im);
  <D.25898>:
  D.25899 = is_wcf_hack_disabled ();
  if (D.25899 != 0) goto <D.25900>; else goto <D.25901>;
  <D.25900>:
  D.25902 = mono_method_can_access_method_full (cm, im, 0B);
  if (D.25902 == 0) goto <D.25903>; else goto <D.25904>;
  <D.25903>:
  {
    char * body_name;
    char * decl_name;

    body_name = mono_method_full_name (cm, 1);
    decl_name = mono_method_full_name (im, 1);
    D.25905 = monoeg_g_strdup_printf ("Method %s overrides method \'%s\' which is not accessible", body_name, decl_name);
    mono_class_set_failure (class, 7, D.25905);
    monoeg_g_free (body_name);
    monoeg_g_free (decl_name);
    D.25869 = 0;
    return D.25869;
  }
  <D.25904>:
  <D.25901>:
  D.25869 = 1;
  return D.25869;
  <D.25863>:
  {
    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.25906>; else goto <D.25907>;
    <D.25906>:
    D.25869 = 0;
    return D.25869;
    <D.25907>:
    D.25908 = cm->klass;
    D.25909 = D.25908->rank;
    if (D.25909 == 0) goto <D.25910>; else goto <D.25911>;
    <D.25910>:
    D.25869 = 0;
    return D.25869;
    <D.25911>:
    cmsig = mono_method_signature (cm);
    imsig = mono_method_signature (im);
    D.25880 = cmsig == 0B;
    D.25881 = imsig == 0B;
    D.25882 = D.25880 | D.25881;
    if (D.25882 != 0) goto <D.25912>; else goto <D.25913>;
    <D.25912>:
    D.25914 = monoeg_strdup ("Could not resolve the signature of a virtual method");
    mono_class_set_failure (class, 7, D.25914);
    D.25869 = 0;
    return D.25869;
    <D.25913>:
    D.25915 = mono_metadata_signature_equal (cmsig, imsig);
    if (D.25915 == 0) goto <D.25916>; else goto <D.25917>;
    <D.25916>:
    D.25869 = 0;
    return D.25869;
    <D.25917>:
    D.25918 = mono_class_get_image (ic);
    D.25919 = mono_defaults.corlib;
    if (D.25918 != D.25919) goto <D.25920>; else goto <D.25921>;
    <D.25920>:
    D.25869 = 0;
    return D.25869;
    <D.25921>:
    if (ic_name_space == 0B) goto <D.25922>; else goto <D.25924>;
    <D.25924>:
    {
      size_t __s1_len;
      size_t __s2_len;

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

        __s2 = ic_name_space;
        D.25928 = "System.Collections.Generic";
        D.25929 = MEM[(const unsigned char *)D.25928];
        D.25930 = (int) D.25929;
        D.25931 = *__s2;
        D.25932 = (int) D.25931;
        __result = D.25930 - D.25932;
        {
          D.25933 = __s2_len != 0;
          D.25934 = __result == 0;
          D.25935 = D.25933 & D.25934;
          if (D.25935 != 0) goto <D.25936>; else goto <D.25937>;
          <D.25936>:
          D.25938 = &MEM[(void *)"System.Collections.Generic" + 1B];
          D.25939 = *D.25938;
          D.25940 = (int) D.25939;
          D.25941 = __s2 + 1;
          D.25942 = *D.25941;
          D.25943 = (int) D.25942;
          __result = D.25940 - D.25943;
          D.25944 = __s2_len > 1;
          D.25934 = __result == 0;
          D.25945 = D.25944 & D.25934;
          if (D.25945 != 0) goto <D.25946>; else goto <D.25947>;
          <D.25946>:
          D.25948 = &MEM[(void *)"System.Collections.Generic" + 2B];
          D.25949 = *D.25948;
          D.25950 = (int) D.25949;
          D.25951 = __s2 + 2;
          D.25952 = *D.25951;
          D.25953 = (int) D.25952;
          __result = D.25950 - D.25953;
          D.25954 = __s2_len > 2;
          D.25934 = __result == 0;
          D.25955 = D.25954 & D.25934;
          if (D.25955 != 0) goto <D.25956>; else goto <D.25957>;
          <D.25956>:
          D.25958 = &MEM[(void *)"System.Collections.Generic" + 3B];
          D.25959 = *D.25958;
          D.25960 = (int) D.25959;
          D.25961 = __s2 + 3;
          D.25962 = *D.25961;
          D.25963 = (int) D.25962;
          __result = D.25960 - D.25963;
          <D.25957>:
          <D.25947>:
          <D.25937>:
        }
        D.19481 = __result;
      }
      iftmp.221 = -D.19481;
      goto <D.25964>;
      <D.25927>:
      iftmp.221 = __builtin_strcmp (ic_name_space, "System.Collections.Generic");
      <D.25964>:
      D.19482 = iftmp.221;
    }
    if (D.19482 != 0) goto <D.25922>; else goto <D.25923>;
    <D.25922>:
    D.25869 = 0;
    return D.25869;
    <D.25923>:
    if (ic_name == 0B) goto <D.25965>; else goto <D.25967>;
    <D.25967>:
    {
      size_t __s1_len;
      size_t __s2_len;

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

        __s2 = ic_name;
        D.25971 = "IEnumerable`1";
        D.25972 = MEM[(const unsigned char *)D.25971];
        D.25973 = (int) D.25972;
        D.25974 = *__s2;
        D.25975 = (int) D.25974;
        __result = D.25973 - D.25975;
        {
          D.25976 = __s2_len != 0;
          D.25977 = __result == 0;
          D.25978 = D.25976 & D.25977;
          if (D.25978 != 0) goto <D.25979>; else goto <D.25980>;
          <D.25979>:
          D.25981 = &MEM[(void *)"IEnumerable`1" + 1B];
          D.25982 = *D.25981;
          D.25983 = (int) D.25982;
          D.25984 = __s2 + 1;
          D.25985 = *D.25984;
          D.25986 = (int) D.25985;
          __result = D.25983 - D.25986;
          D.25987 = __s2_len > 1;
          D.25977 = __result == 0;
          D.25988 = D.25987 & D.25977;
          if (D.25988 != 0) goto <D.25989>; else goto <D.25990>;
          <D.25989>:
          D.25991 = &MEM[(void *)"IEnumerable`1" + 2B];
          D.25992 = *D.25991;
          D.25993 = (int) D.25992;
          D.25994 = __s2 + 2;
          D.25995 = *D.25994;
          D.25996 = (int) D.25995;
          __result = D.25993 - D.25996;
          D.25997 = __s2_len > 2;
          D.25977 = __result == 0;
          D.25998 = D.25997 & D.25977;
          if (D.25998 != 0) goto <D.25999>; else goto <D.26000>;
          <D.25999>:
          D.26001 = &MEM[(void *)"IEnumerable`1" + 3B];
          D.26002 = *D.26001;
          D.26003 = (int) D.26002;
          D.26004 = __s2 + 3;
          D.26005 = *D.26004;
          D.26006 = (int) D.26005;
          __result = D.26003 - D.26006;
          <D.26000>:
          <D.25990>:
          <D.25980>:
        }
        D.19490 = __result;
      }
      iftmp.222 = -D.19490;
      goto <D.26007>;
      <D.25970>:
      iftmp.222 = __builtin_strcmp (ic_name, "IEnumerable`1");
      <D.26007>:
      D.19491 = iftmp.222;
    }
    if (D.19491 != 0) goto <D.26008>; else goto <D.25966>;
    <D.26008>:
    {
      size_t __s1_len;
      size_t __s2_len;

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

        __s2 = ic_name;
        D.26012 = "ICollection`1";
        D.26013 = MEM[(const unsigned char *)D.26012];
        D.26014 = (int) D.26013;
        D.26015 = *__s2;
        D.26016 = (int) D.26015;
        __result = D.26014 - D.26016;
        {
          D.26017 = __s2_len != 0;
          D.26018 = __result == 0;
          D.26019 = D.26017 & D.26018;
          if (D.26019 != 0) goto <D.26020>; else goto <D.26021>;
          <D.26020>:
          D.26022 = &MEM[(void *)"ICollection`1" + 1B];
          D.26023 = *D.26022;
          D.26024 = (int) D.26023;
          D.26025 = __s2 + 1;
          D.26026 = *D.26025;
          D.26027 = (int) D.26026;
          __result = D.26024 - D.26027;
          D.26028 = __s2_len > 1;
          D.26018 = __result == 0;
          D.26029 = D.26028 & D.26018;
          if (D.26029 != 0) goto <D.26030>; else goto <D.26031>;
          <D.26030>:
          D.26032 = &MEM[(void *)"ICollection`1" + 2B];
          D.26033 = *D.26032;
          D.26034 = (int) D.26033;
          D.26035 = __s2 + 2;
          D.26036 = *D.26035;
          D.26037 = (int) D.26036;
          __result = D.26034 - D.26037;
          D.26038 = __s2_len > 2;
          D.26018 = __result == 0;
          D.26039 = D.26038 & D.26018;
          if (D.26039 != 0) goto <D.26040>; else goto <D.26041>;
          <D.26040>:
          D.26042 = &MEM[(void *)"ICollection`1" + 3B];
          D.26043 = *D.26042;
          D.26044 = (int) D.26043;
          D.26045 = __s2 + 3;
          D.26046 = *D.26045;
          D.26047 = (int) D.26046;
          __result = D.26044 - D.26047;
          <D.26041>:
          <D.26031>:
          <D.26021>:
        }
        D.19499 = __result;
      }
      iftmp.223 = -D.19499;
      goto <D.26048>;
      <D.26011>:
      iftmp.223 = __builtin_strcmp (ic_name, "ICollection`1");
      <D.26048>:
      D.19500 = iftmp.223;
    }
    if (D.19500 != 0) goto <D.26049>; else goto <D.25966>;
    <D.26049>:
    {
      size_t __s1_len;
      size_t __s2_len;

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

        __s2 = ic_name;
        D.26053 = "IList`1";
        D.26054 = MEM[(const unsigned char *)D.26053];
        D.26055 = (int) D.26054;
        D.26056 = *__s2;
        D.26057 = (int) D.26056;
        __result = D.26055 - D.26057;
        {
          D.26058 = __s2_len != 0;
          D.26059 = __result == 0;
          D.26060 = D.26058 & D.26059;
          if (D.26060 != 0) goto <D.26061>; else goto <D.26062>;
          <D.26061>:
          D.26063 = &MEM[(void *)"IList`1" + 1B];
          D.26064 = *D.26063;
          D.26065 = (int) D.26064;
          D.26066 = __s2 + 1;
          D.26067 = *D.26066;
          D.26068 = (int) D.26067;
          __result = D.26065 - D.26068;
          D.26069 = __s2_len > 1;
          D.26059 = __result == 0;
          D.26070 = D.26069 & D.26059;
          if (D.26070 != 0) goto <D.26071>; else goto <D.26072>;
          <D.26071>:
          D.26073 = &MEM[(void *)"IList`1" + 2B];
          D.26074 = *D.26073;
          D.26075 = (int) D.26074;
          D.26076 = __s2 + 2;
          D.26077 = *D.26076;
          D.26078 = (int) D.26077;
          __result = D.26075 - D.26078;
          D.26079 = __s2_len > 2;
          D.26059 = __result == 0;
          D.26080 = D.26079 & D.26059;
          if (D.26080 != 0) goto <D.26081>; else goto <D.26082>;
          <D.26081>:
          D.26083 = &MEM[(void *)"IList`1" + 3B];
          D.26084 = *D.26083;
          D.26085 = (int) D.26084;
          D.26086 = __s2 + 3;
          D.26087 = *D.26086;
          D.26088 = (int) D.26087;
          __result = D.26085 - D.26088;
          <D.26082>:
          <D.26072>:
          <D.26062>:
        }
        D.19508 = __result;
      }
      iftmp.224 = -D.19508;
      goto <D.26089>;
      <D.26052>:
      iftmp.224 = __builtin_strcmp (ic_name, "IList`1");
      <D.26089>:
      D.19509 = iftmp.224;
    }
    if (D.19509 != 0) goto <D.26090>; else goto <D.25966>;
    <D.26090>:
    {
      size_t __s1_len;
      size_t __s2_len;

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

        __s2 = ic_name;
        D.26094 = "IReadOnlyList`1";
        D.26095 = MEM[(const unsigned char *)D.26094];
        D.26096 = (int) D.26095;
        D.26097 = *__s2;
        D.26098 = (int) D.26097;
        __result = D.26096 - D.26098;
        {
          D.26099 = __s2_len != 0;
          D.26100 = __result == 0;
          D.26101 = D.26099 & D.26100;
          if (D.26101 != 0) goto <D.26102>; else goto <D.26103>;
          <D.26102>:
          D.26104 = &MEM[(void *)"IReadOnlyList`1" + 1B];
          D.26105 = *D.26104;
          D.26106 = (int) D.26105;
          D.26107 = __s2 + 1;
          D.26108 = *D.26107;
          D.26109 = (int) D.26108;
          __result = D.26106 - D.26109;
          D.26110 = __s2_len > 1;
          D.26100 = __result == 0;
          D.26111 = D.26110 & D.26100;
          if (D.26111 != 0) goto <D.26112>; else goto <D.26113>;
          <D.26112>:
          D.26114 = &MEM[(void *)"IReadOnlyList`1" + 2B];
          D.26115 = *D.26114;
          D.26116 = (int) D.26115;
          D.26117 = __s2 + 2;
          D.26118 = *D.26117;
          D.26119 = (int) D.26118;
          __result = D.26116 - D.26119;
          D.26120 = __s2_len > 2;
          D.26100 = __result == 0;
          D.26121 = D.26120 & D.26100;
          if (D.26121 != 0) goto <D.26122>; else goto <D.26123>;
          <D.26122>:
          D.26124 = &MEM[(void *)"IReadOnlyList`1" + 3B];
          D.26125 = *D.26124;
          D.26126 = (int) D.26125;
          D.26127 = __s2 + 3;
          D.26128 = *D.26127;
          D.26129 = (int) D.26128;
          __result = D.26126 - D.26129;
          <D.26123>:
          <D.26113>:
          <D.26103>:
        }
        D.19517 = __result;
      }
      iftmp.225 = -D.19517;
      goto <D.26130>;
      <D.26093>:
      iftmp.225 = __builtin_strcmp (ic_name, "IReadOnlyList`1");
      <D.26130>:
      D.19518 = iftmp.225;
    }
    if (D.19518 != 0) goto <D.26131>; else goto <D.25966>;
    <D.26131>:
    {
      size_t __s1_len;
      size_t __s2_len;

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

        __s2 = ic_name;
        D.26135 = "IReadOnlyCollection`1";
        D.26136 = MEM[(const unsigned char *)D.26135];
        D.26137 = (int) D.26136;
        D.26138 = *__s2;
        D.26139 = (int) D.26138;
        __result = D.26137 - D.26139;
        {
          D.26140 = __s2_len != 0;
          D.26141 = __result == 0;
          D.26142 = D.26140 & D.26141;
          if (D.26142 != 0) goto <D.26143>; else goto <D.26144>;
          <D.26143>:
          D.26145 = &MEM[(void *)"IReadOnlyCollection`1" + 1B];
          D.26146 = *D.26145;
          D.26147 = (int) D.26146;
          D.26148 = __s2 + 1;
          D.26149 = *D.26148;
          D.26150 = (int) D.26149;
          __result = D.26147 - D.26150;
          D.26151 = __s2_len > 1;
          D.26141 = __result == 0;
          D.26152 = D.26151 & D.26141;
          if (D.26152 != 0) goto <D.26153>; else goto <D.26154>;
          <D.26153>:
          D.26155 = &MEM[(void *)"IReadOnlyCollection`1" + 2B];
          D.26156 = *D.26155;
          D.26157 = (int) D.26156;
          D.26158 = __s2 + 2;
          D.26159 = *D.26158;
          D.26160 = (int) D.26159;
          __result = D.26157 - D.26160;
          D.26161 = __s2_len > 2;
          D.26141 = __result == 0;
          D.26162 = D.26161 & D.26141;
          if (D.26162 != 0) goto <D.26163>; else goto <D.26164>;
          <D.26163>:
          D.26165 = &MEM[(void *)"IReadOnlyCollection`1" + 3B];
          D.26166 = *D.26165;
          D.26167 = (int) D.26166;
          D.26168 = __s2 + 3;
          D.26169 = *D.26168;
          D.26170 = (int) D.26169;
          __result = D.26167 - D.26170;
          <D.26164>:
          <D.26154>:
          <D.26144>:
        }
        D.19526 = __result;
      }
      iftmp.226 = -D.19526;
      goto <D.26171>;
      <D.26134>:
      iftmp.226 = __builtin_strcmp (ic_name, "IReadOnlyCollection`1");
      <D.26171>:
      D.19527 = iftmp.226;
    }
    if (D.19527 != 0) goto <D.25965>; else goto <D.25966>;
    <D.25965>:
    D.25869 = 0;
    return D.25869;
    <D.25966>:
    D.25860 = cm->name;
    subname = strstr (D.25860, ic_name_space);
    D.25860 = cm->name;
    if (D.25860 != subname) goto <D.26172>; else goto <D.26173>;
    <D.26172>:
    D.25869 = 0;
    return D.25869;
    <D.26173>:
    D.26174 = strlen (ic_name_space);
    subname = subname + D.26174;
    D.26175 = *subname;
    if (D.26175 != 46) goto <D.26176>; else goto <D.26177>;
    <D.26176>:
    D.25869 = 0;
    return D.25869;
    <D.26177>:
    subname = subname + 1;
    D.26178 = strstr (subname, ic_name);
    if (D.26178 != subname) goto <D.26179>; else goto <D.26180>;
    <D.26179>:
    D.25869 = 0;
    return D.25869;
    <D.26180>:
    D.26181 = strlen (ic_name);
    subname = subname + D.26181;
    D.26175 = *subname;
    if (D.26175 != 46) goto <D.26182>; else goto <D.26183>;
    <D.26182>:
    D.25869 = 0;
    return D.25869;
    <D.26183>:
    subname = subname + 1;
    {
      size_t __s1_len;
      size_t __s2_len;

      D.25861 = im->name;
      D.19536 = __builtin_strcmp (subname, D.25861);
    }
    if (D.19536 != 0) goto <D.26184>; else goto <D.26185>;
    <D.26184>:
    D.25869 = 0;
    return D.25869;
    <D.26185>:
    if (security_enabled != 0) goto <D.26186>; else goto <D.26187>;
    <D.26186>:
    D.25891 = im->flags;
    D.25892 = (int) D.25891;
    D.25893 = D.25892 & 16384;
    if (D.25893 != 0) goto <D.26188>; else goto <D.26189>;
    <D.26188>:
    mono_secman_inheritancedemand_method (cm, im);
    <D.26189>:
    <D.26187>:
    D.26190 = mono_security_get_mode ();
    if (D.26190 == 1) goto <D.26191>; else goto <D.26192>;
    <D.26191>:
    mono_security_core_clr_check_override (class, cm, im);
    <D.26192>:
    D.26193 = is_wcf_hack_disabled ();
    if (D.26193 != 0) goto <D.26194>; else goto <D.26195>;
    <D.26194>:
    D.26196 = mono_method_can_access_method_full (cm, im, 0B);
    if (D.26196 == 0) goto <D.26197>; else goto <D.26198>;
    <D.26197>:
    {
      char * body_name;
      char * decl_name;

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


print_unimplemented_interface_method_info (struct MonoClass * class, struct MonoClass * ic, struct MonoMethod * im, int im_slot, struct MonoMethod * * overrides, int onum)
{
  unsigned int index.227;
  unsigned int D.26202;
  struct MonoMethod * * D.26203;
  struct MonoMethod * D.26204;
  short int D.26205;
  int D.26206;
  const char * D.26207;
  sizetype index.228;
  sizetype D.26209;
  sizetype D.26210;
  struct MonoMethod * * D.26211;
  struct MonoMethod * D.26212;
  short int D.26213;
  int D.26214;
  const char * D.26215;
  struct MonoMethodSignature * D.26216;
  struct MonoType * D.26217;
  const char * D.26218;
  struct MonoType * D.26219;
  char * D.26220;
  unsigned char D.26221;
  struct MonoMethod * * D.26224;
  unsigned int D.26225;
  struct MonoMethod * * D.26226;
  struct MonoMethodSignature * D.26227;
  const char * D.26228;
  unsigned int index.229;
  unsigned int D.26230;
  int index;
  char * method_signature;
  char * type_name;

  index = 0;
  goto <D.19551>;
  <D.19550>:
  index.227 = (unsigned int) index;
  D.26202 = index.227 * 8;
  D.26203 = overrides + D.26202;
  D.26204 = *D.26203;
  D.26205 = D.26204->slot;
  D.26206 = (int) D.26205;
  index.227 = (unsigned int) index;
  D.26202 = index.227 * 8;
  D.26203 = overrides + D.26202;
  D.26204 = *D.26203;
  D.26207 = D.26204->name;
  index.228 = (sizetype) index;
  D.26209 = index.228 * 8;
  D.26210 = D.26209 + 4;
  D.26211 = overrides + D.26210;
  D.26212 = *D.26211;
  D.26213 = D.26212->slot;
  D.26214 = (int) D.26213;
  index.228 = (sizetype) index;
  D.26209 = index.228 * 8;
  D.26210 = D.26209 + 4;
  D.26211 = overrides + D.26210;
  D.26212 = *D.26211;
  D.26215 = D.26212->name;
  mono_trace (16, 2, " at slot %d: %s (%d) overrides %s (%d)\n", im_slot, D.26215, D.26214, D.26207, D.26206);
  index = index + 1;
  <D.19551>:
  if (index < onum) goto <D.19550>; else goto <D.19552>;
  <D.19552>:
  D.26216 = mono_method_signature (im);
  method_signature = mono_signature_get_desc (D.26216, 0);
  D.26217 = &class->byval_arg;
  type_name = mono_type_full_name (D.26217);
  D.26218 = im->name;
  D.26219 = &ic->byval_arg;
  D.26220 = mono_type_get_name (D.26219);
  mono_trace (16, 2, "no implementation for interface method %s::%s(%s) in class %s\n", D.26220, D.26218, method_signature, type_name);
  monoeg_g_free (method_signature);
  monoeg_g_free (type_name);
  mono_class_setup_methods (class);
  D.26221 = class->exception_type;
  if (D.26221 != 0) goto <D.26222>; else goto <D.26223>;
  <D.26222>:
  {
    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.26223>:
  index = 0;
  goto <D.19556>;
  <D.19555>:
  {
    struct MonoMethod * cm;

    D.26224 = class->methods;
    index.227 = (unsigned int) index;
    D.26225 = index.227 * 4;
    D.26226 = D.26224 + D.26225;
    cm = *D.26226;
    D.26227 = mono_method_signature (cm);
    method_signature = mono_signature_get_desc (D.26227, 1);
    D.26228 = cm->name;
    mono_trace (16, 2, "METHOD %s(%s)\n", D.26228, method_signature);
    monoeg_g_free (method_signature);
  }
  index = index + 1;
  <D.19556>:
  index.229 = (unsigned int) index;
  D.26230 = class->method.count;
  if (index.229 < D.26230) goto <D.19555>; else goto <D.19557>;
  <D.19557>:
}


is_wcf_hack_disabled ()
{
  int inited.230;
  const gchar * D.26235;
  _Bool D.26236;
  int disabled.231;
  gboolean D.26238;
  static gboolean disabled;
  static gboolean inited = 0;

  inited.230 = inited;
  if (inited.230 == 0) goto <D.26233>; else goto <D.26234>;
  <D.26233>:
  D.26235 = monoeg_g_getenv ("MONO_DISABLE_WCF_HACK");
  D.26236 = D.26235 != 0B;
  disabled.231 = (int) D.26236;
  disabled = disabled.231;
  inited = 1;
  <D.26234>:
  D.26238 = disabled;
  return D.26238;
}


mono_class_get_virtual_methods (struct MonoClass * klass, void * * iter)
{
  struct MonoMethod * D.26242;
  struct MonoMethod * * D.26245;
  unsigned int D.26247;
  struct MonoImage * D.26249;
  unsigned char D.26250;
  unsigned char D.26251;
  struct MonoGenericClass * D.26253;
  void * D.26254;
  struct MonoMethod * D.26260;
  short unsigned int D.26263;
  int D.26264;
  int D.26265;
  unsigned int D.26267;
  unsigned int D.26268;
  struct MonoMethod * * D.26269;
  unsigned int D.26275;
  unsigned int i.232;
  unsigned int D.26277;
  int D.26278;
  unsigned int D.26279;
  unsigned int D.26283;
  unsigned int D.26284;
  int D.26285;
  void * D.26286;
  struct MonoMethod * * method;

  if (iter == 0B) goto <D.26240>; else goto <D.26241>;
  <D.26240>:
  D.26242 = 0B;
  return D.26242;
  <D.26241>:
  D.26245 = klass->methods;
  if (D.26245 != 0B) goto <D.26243>; else goto <D.26246>;
  <D.26246>:
  D.26247 = klass->type_token;
  if (D.26247 == 0) goto <D.26243>; else goto <D.26248>;
  <D.26248>:
  D.26249 = klass->image;
  D.26250 = BIT_FIELD_REF <*D.26249, 8, 128>;
  D.26251 = D.26250 & 8;
  if (D.26251 != 0) goto <D.26243>; else goto <D.26252>;
  <D.26252>:
  D.26253 = klass->generic_class;
  if (D.26253 != 0B) goto <D.26243>; else goto <D.26244>;
  <D.26243>:
  D.26254 = *iter;
  if (D.26254 == 0B) goto <D.26255>; else goto <D.26256>;
  <D.26255>:
  mono_class_setup_methods (klass);
  D.26245 = klass->methods;
  if (D.26245 == 0B) goto <D.26257>; else goto <D.26258>;
  <D.26257>:
  D.26242 = 0B;
  return D.26242;
  <D.26258>:
  method = klass->methods;
  goto <D.26259>;
  <D.26256>:
  method = *iter;
  method = method + 4;
  <D.26259>:
  goto <D.21253>;
  <D.21252>:
  D.26260 = *method;
  if (D.26260 != 0B) goto <D.26261>; else goto <D.26262>;
  <D.26261>:
  D.26260 = *method;
  D.26263 = D.26260->flags;
  D.26264 = (int) D.26263;
  D.26265 = D.26264 & 64;
  if (D.26265 != 0) goto <D.21251>; else goto <D.26266>;
  <D.26266>:
  <D.26262>:
  method = method + 4;
  <D.21253>:
  D.26245 = klass->methods;
  D.26267 = klass->method.count;
  D.26268 = D.26267 * 4;
  D.26269 = D.26245 + D.26268;
  if (D.26269 > method) goto <D.21252>; else goto <D.21251>;
  <D.21251>:
  D.26245 = klass->methods;
  D.26267 = klass->method.count;
  D.26268 = D.26267 * 4;
  D.26269 = D.26245 + D.26268;
  if (D.26269 > method) goto <D.26270>; else goto <D.26271>;
  <D.26270>:
  *iter = method;
  D.26242 = *method;
  return D.26242;
  <D.26271>:
  D.26242 = 0B;
  return D.26242;
  <D.26244>:
  {
    struct MonoMethod * res;
    int i;
    int start_index;

    res = 0B;
    D.26254 = *iter;
    if (D.26254 == 0B) goto <D.26272>; else goto <D.26273>;
    <D.26272>:
    start_index = 0;
    goto <D.26274>;
    <D.26273>:
    D.26254 = *iter;
    start_index = (int) D.26254;
    <D.26274>:
    i = start_index;
    goto <D.21260>;
    <D.21259>:
    {
      guint32 flags;

      D.26275 = klass->method.first;
      i.232 = (unsigned int) i;
      D.26277 = D.26275 + i.232;
      D.26278 = (int) D.26277;
      D.26249 = klass->image;
      flags = mono_metadata_decode_table_row_col (D.26249, 6, D.26278, 2);
      D.26279 = flags & 64;
      if (D.26279 != 0) goto <D.21258>; else goto <D.26280>;
      <D.26280>:
    }
    i = i + 1;
    <D.21260>:
    i.232 = (unsigned int) i;
    D.26267 = klass->method.count;
    if (i.232 < D.26267) goto <D.21259>; else goto <D.21258>;
    <D.21258>:
    i.232 = (unsigned int) i;
    D.26267 = klass->method.count;
    if (i.232 < D.26267) goto <D.26281>; else goto <D.26282>;
    <D.26281>:
    D.26275 = klass->method.first;
    i.232 = (unsigned int) i;
    D.26277 = D.26275 + i.232;
    D.26283 = D.26277 + 1;
    D.26284 = D.26283 | 100663296;
    D.26249 = klass->image;
    res = mono_get_method (D.26249, D.26284, klass);
    D.26285 = i + 1;
    D.26286 = (void *) D.26285;
    *iter = D.26286;
    D.26242 = res;
    return D.26242;
    <D.26282>:
    D.26242 = 0B;
    return D.26242;
  }
}


print_implemented_interfaces (struct MonoClass * klass)
{
  short unsigned int D.26288;
  int D.26289;
  struct MonoClass * * D.26290;
  unsigned int i.233;
  unsigned int D.26292;
  struct MonoClass * * D.26293;
  struct MonoClass * D.26294;
  const char * D.26295;
  const char * D.26296;
  unsigned int D.26297;
  guint16 * D.26298;
  unsigned int D.26299;
  guint16 * D.26300;
  short unsigned int D.26301;
  int D.26302;
  short unsigned int D.26303;
  int D.26304;
  short unsigned int D.26307;
  int D.26308;
  guint8 * D.26310;
  int D.26311;
  sizetype D.26312;
  guint8 * D.26313;
  unsigned char D.26314;
  int D.26315;
  int D.26316;
  int D.26317;
  int D.26318;
  sizetype i.234;
  guint8 * D.26321;
  unsigned char D.26322;
  int D.26323;
  int D.26324;
  int D.26325;
  int D.26326;
  _Bool D.26327;
  int D.26328;
  int D.26329;
  const char * D.26330;
  int D.26331;
  const char * D.26334;
  void * * D.26338;
  void * * D.26339;
  const char * D.26340;
  short unsigned int D.26341;
  int D.26342;
  const char * D.26343;
  unsigned int D.26344;
  int D.26345;
  unsigned int i.235;
  unsigned int D.26347;
  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.26288 = klass->interface_offsets_count;
      D.26289 = (int) D.26288;
      printf ("Packed interface table for class %s has size %d\n", name, D.26289);
      monoeg_g_free (name);
      i = 0;
      goto <D.19140>;
      <D.19139>:
      D.26290 = klass->interfaces_packed;
      i.233 = (unsigned int) i;
      D.26292 = i.233 * 4;
      D.26293 = D.26290 + D.26292;
      D.26294 = *D.26293;
      D.26295 = D.26294->name;
      D.26290 = klass->interfaces_packed;
      i.233 = (unsigned int) i;
      D.26292 = i.233 * 4;
      D.26293 = D.26290 + D.26292;
      D.26294 = *D.26293;
      D.26296 = D.26294->name_space;
      D.26290 = klass->interfaces_packed;
      i.233 = (unsigned int) i;
      D.26292 = i.233 * 4;
      D.26293 = D.26290 + D.26292;
      D.26294 = *D.26293;
      D.26297 = D.26294->method.count;
      D.26298 = klass->interface_offsets_packed;
      i.233 = (unsigned int) i;
      D.26299 = i.233 * 2;
      D.26300 = D.26298 + D.26299;
      D.26301 = *D.26300;
      D.26302 = (int) D.26301;
      D.26290 = klass->interfaces_packed;
      i.233 = (unsigned int) i;
      D.26292 = i.233 * 4;
      D.26293 = D.26290 + D.26292;
      D.26294 = *D.26293;
      D.26303 = D.26294->interface_id;
      D.26304 = (int) D.26303;
      printf ("  [%03d][UUID %03d][SLOT %03d][SIZE  %03d] interface %s.%s\n", i, D.26304, D.26302, D.26297, D.26296, D.26295);
      i = i + 1;
      <D.19140>:
      D.26288 = klass->interface_offsets_count;
      D.26289 = (int) D.26288;
      if (D.26289 > i) goto <D.19139>; else goto <D.19141>;
      <D.19141>:
      printf ("Interface flags: ");
      i = 0;
      goto <D.19143>;
      <D.19142>:
      D.26307 = klass->max_interface_id;
      D.26308 = (int) D.26307;
      if (D.26308 >= i) goto <D.26309>; else goto <D.26305>;
      <D.26309>:
      D.26310 = klass->interface_bitmap;
      D.26311 = i >> 3;
      D.26312 = (sizetype) D.26311;
      D.26313 = D.26310 + D.26312;
      D.26314 = *D.26313;
      D.26315 = (int) D.26314;
      D.26316 = i & 7;
      D.26317 = D.26315 >> D.26316;
      D.26318 = D.26317 & 1;
      if (D.26318 != 0) goto <D.26319>; else goto <D.26305>;
      <D.26319>:
      printf ("(%d,T)", i);
      goto <D.26306>;
      <D.26305>:
      printf ("(%d,F)", i);
      <D.26306>:
      i = i + 1;
      <D.19143>:
      D.26307 = klass->max_interface_id;
      D.26308 = (int) D.26307;
      if (D.26308 >= i) goto <D.19142>; else goto <D.19144>;
      <D.19144>:
      printf ("\n");
      printf ("Dump interface flags:");
      i = 0;
      goto <D.19146>;
      <D.19145>:
      D.26310 = klass->interface_bitmap;
      i.234 = (sizetype) i;
      D.26321 = D.26310 + i.234;
      D.26322 = *D.26321;
      D.26323 = (int) D.26322;
      printf (" %02X", D.26323);
      i = i + 1;
      <D.19146>:
      D.26307 = klass->max_interface_id;
      D.26308 = (int) D.26307;
      D.26324 = D.26308 + 1;
      D.26325 = D.26324 >> 3;
      D.26307 = klass->max_interface_id;
      D.26308 = (int) D.26307;
      D.26324 = D.26308 + 1;
      D.26326 = D.26324 & 7;
      D.26327 = D.26326 != 0;
      D.26328 = (int) D.26327;
      D.26329 = D.26325 + D.26328;
      if (D.26329 > i) goto <D.19145>; else goto <D.19147>;
      <D.19147>:
      printf ("\n");
      goto <D.19153>;
      <D.19152>:
      D.26330 = klass->name;
      printf ("[LEVEL %d] Implemented interfaces by class %s:\n", ancestor_level, D.26330);
      ifaces = mono_class_get_implemented_interfaces (klass, &error);
      D.26331 = mono_error_ok (&error);
      if (D.26331 == 0) goto <D.26332>; else goto <D.26333>;
      <D.26332>:
      D.26334 = mono_error_get_message (&error);
      printf ("  Type failed due to %s\n", D.26334);
      mono_error_cleanup (&error);
      goto <D.26335>;
      <D.26333>:
      if (ifaces != 0B) goto <D.26336>; else goto <D.26337>;
      <D.26336>:
      i = 0;
      goto <D.19150>;
      <D.19149>:
      {
        struct MonoClass * ic;

        D.26338 = ifaces->pdata;
        i.233 = (unsigned int) i;
        D.26292 = i.233 * 4;
        D.26339 = D.26338 + D.26292;
        ic = *D.26339;
        D.26340 = ic->name;
        D.26341 = ic->interface_id;
        D.26342 = (int) D.26341;
        printf ("  [UIID %d] interface %s\n", D.26342, D.26340);
        D.26340 = ic->name;
        D.26343 = ic->name_space;
        D.26344 = ic->method.count;
        D.26345 = mono_class_interface_offset (klass, ic);
        D.26341 = ic->interface_id;
        D.26342 = (int) D.26341;
        printf ("  [%03d][UUID %03d][SLOT %03d][SIZE  %03d] interface %s.%s\n", i, D.26342, D.26345, D.26344, D.26343, D.26340);
      }
      i = i + 1;
      <D.19150>:
      i.235 = (unsigned int) i;
      D.26347 = ifaces->len;
      if (i.235 < D.26347) goto <D.19149>; else goto <D.19151>;
      <D.19151>:
      monoeg_g_ptr_array_free (ifaces, 1);
      <D.26337>:
      <D.26335>:
      ancestor_level = ancestor_level + 1;
      klass = klass->parent;
      <D.19153>:
      if (klass != 0B) goto <D.19152>; else goto <D.19154>;
      <D.19154>:
    }
  finally
    {
      error = {CLOBBER};
    }
}


printf (const char * restrict __fmt)
{
  int D.26348;

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


mono_method_get_vtable_slot (struct MonoMethod * method)
{
  short int D.26350;
  struct MonoClass * D.26353;
  unsigned char D.26354;
  int D.26357;
  struct MonoGenericClass * D.26360;
  _Bool D.26361;
  long int D.26362;
  long int D.26363;
  struct MonoMethod * * D.26366;
  _Bool D.26367;
  long int D.26368;
  long int D.26369;
  unsigned int i.236;
  unsigned int D.26373;
  struct MonoMethod * * D.26374;
  struct MonoMethod * D.26375;
  unsigned int i.237;
  unsigned int D.26378;
  _Bool D.26379;
  long int D.26380;
  long int D.26381;
  struct MonoMethod * * D.26384;
  _Bool D.26385;
  long int D.26386;
  long int D.26387;
  struct MonoMethod * * D.26390;
  struct MonoMethod * D.26391;
  short int D.26392;
  _Bool D.26393;
  long int D.26394;
  long int D.26395;

  D.26350 = method->slot;
  if (D.26350 == -1) goto <D.26351>; else goto <D.26352>;
  <D.26351>:
  D.26353 = method->klass;
  mono_class_setup_vtable (D.26353);
  D.26353 = method->klass;
  D.26354 = D.26353->exception_type;
  if (D.26354 != 0) goto <D.26355>; else goto <D.26356>;
  <D.26355>:
  D.26357 = -1;
  return D.26357;
  <D.26356>:
  D.26350 = method->slot;
  if (D.26350 == -1) goto <D.26358>; else goto <D.26359>;
  <D.26358>:
  {
    struct MonoClass * gklass;
    int i;

    D.26353 = method->klass;
    D.26360 = D.26353->generic_class;
    D.26361 = D.26360 == 0B;
    D.26362 = (long int) D.26361;
    D.26363 = __builtin_expect (D.26362, 0);
    if (D.26363 != 0) goto <D.26364>; else goto <D.26365>;
    <D.26364>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "class.c", 4676, "method->klass->generic_class");
    <D.26365>:
    D.26353 = method->klass;
    D.26360 = D.26353->generic_class;
    gklass = D.26360->container_class;
    D.26353 = method->klass;
    mono_class_setup_methods (D.26353);
    D.26353 = method->klass;
    D.26366 = D.26353->methods;
    D.26367 = D.26366 == 0B;
    D.26368 = (long int) D.26367;
    D.26369 = __builtin_expect (D.26368, 0);
    if (D.26369 != 0) goto <D.26370>; else goto <D.26371>;
    <D.26370>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "class.c", 4679, "method->klass->methods");
    <D.26371>:
    i = 0;
    goto <D.19748>;
    <D.19747>:
    D.26353 = method->klass;
    D.26366 = D.26353->methods;
    i.236 = (unsigned int) i;
    D.26373 = i.236 * 4;
    D.26374 = D.26366 + D.26373;
    D.26375 = *D.26374;
    if (D.26375 == method) goto <D.19746>; else goto <D.26376>;
    <D.26376>:
    i = i + 1;
    <D.19748>:
    i.237 = (unsigned int) i;
    D.26353 = method->klass;
    D.26378 = D.26353->method.count;
    if (i.237 < D.26378) goto <D.19747>; else goto <D.19746>;
    <D.19746>:
    i.237 = (unsigned int) i;
    D.26353 = method->klass;
    D.26378 = D.26353->method.count;
    D.26379 = i.237 >= D.26378;
    D.26380 = (long int) D.26379;
    D.26381 = __builtin_expect (D.26380, 0);
    if (D.26381 != 0) goto <D.26382>; else goto <D.26383>;
    <D.26382>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "class.c", 4684, "i < method->klass->method.count");
    <D.26383>:
    D.26384 = gklass->methods;
    D.26385 = D.26384 == 0B;
    D.26386 = (long int) D.26385;
    D.26387 = __builtin_expect (D.26386, 0);
    if (D.26387 != 0) goto <D.26388>; else goto <D.26389>;
    <D.26388>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "class.c", 4685, "gklass->methods");
    <D.26389>:
    D.26384 = gklass->methods;
    i.236 = (unsigned int) i;
    D.26373 = i.236 * 4;
    D.26390 = D.26384 + D.26373;
    D.26391 = *D.26390;
    D.26392 = D.26391->slot;
    method->slot = D.26392;
  }
  <D.26359>:
  D.26350 = method->slot;
  D.26393 = D.26350 == -1;
  D.26394 = (long int) D.26393;
  D.26395 = __builtin_expect (D.26394, 0);
  if (D.26395 != 0) goto <D.26396>; else goto <D.26397>;
  <D.26396>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "class.c", 4688, "method->slot != -1");
  <D.26397>:
  <D.26352>:
  D.26350 = method->slot;
  D.26357 = (int) D.26350;
  return D.26357;
}


mono_method_get_vtable_index (struct MonoMethod * method)
{
  unsigned char D.26399;
  unsigned char D.26400;
  short unsigned int D.26403;
  int D.26404;
  int D.26405;
  struct MonoMethod * D.26408;
  unsigned char D.26409;
  unsigned char D.26410;
  int D.26413;

  D.26399 = BIT_FIELD_REF <*method, 8, 168>;
  D.26400 = D.26399 & 16;
  if (D.26400 != 0) goto <D.26401>; else goto <D.26402>;
  <D.26401>:
  D.26403 = method->flags;
  D.26404 = (int) D.26403;
  D.26405 = D.26404 & 64;
  if (D.26405 != 0) goto <D.26406>; else goto <D.26407>;
  <D.26406>:
  {
    struct MonoMethodInflated * imethod;

    imethod = method;
    D.26408 = imethod->declaring;
    D.26409 = BIT_FIELD_REF <*D.26408, 8, 168>;
    D.26410 = D.26409 & 8;
    if (D.26410 != 0) goto <D.26411>; else goto <D.26412>;
    <D.26411>:
    D.26408 = imethod->declaring;
    D.26413 = mono_method_get_vtable_slot (D.26408);
    return D.26413;
    <D.26412>:
  }
  <D.26407>:
  <D.26402>:
  D.26413 = mono_method_get_vtable_slot (method);
  return D.26413;
}


mono_class_init (struct MonoClass * class)
{
  _Bool D.26415;
  long int D.26416;
  long int D.26417;
  unsigned char D.26422;
  unsigned char D.26423;
  unsigned char D.26425;
  mono_bool D.26426;
  _Bool D.26427;
  unsigned char D.26431;
  gchar * D.26434;
  int D.26435;
  int D.26438;
  struct MonoImage * D.26441;
  const char * D.26442;
  const char * D.26443;
  char * D.26444;
  unsigned char D.26445;
  _Bool D.26446;
  _Bool D.26447;
  _Bool D.26448;
  unsigned char D.26451;
  unsigned char D.26452;
  unsigned char D.26455;
  int D.26458;
  struct MonoClass * D.26461;
  unsigned int D.26464;
  unsigned int D.26465;
  long unsigned int D.26468;
  long unsigned int D.26469;
  struct MonoGenericClass * D.26470;
  unsigned char D.26473;
  unsigned char D.26474;
  long unsigned int D.26477;
  long unsigned int D.26478;
  unsigned char D.26479;
  gchar * D.26484;
  unsigned int D.26487;
  unsigned int D.26488;
  unsigned char D.26490;
  unsigned int D.26492;
  short unsigned int D.26493;
  unsigned char D.26496;
  unsigned char D.26497;
  unsigned char D.26503;
  unsigned char D.26504;
  unsigned int D.26506;
  unsigned char D.26509;
  unsigned char D.26510;
  unsigned int D.26513;
  int D.26514;
  unsigned int D.26515;
  int D.26516;
  unsigned int D.26517;
  unsigned char D.26518;
  <unnamed-unsigned:4> D.26519;
  unsigned int D.26520;
  unsigned char D.26521;
  <unnamed-unsigned:1> D.26522;
  <unnamed-unsigned:1> D.26523;
  <unnamed-unsigned:1> D.26524;
  <unnamed-unsigned:1> D.26525;
  unsigned char D.26527;
  struct MonoLoaderError * D.26531;
  unsigned char D.26533;
  guint32 iftmp.238;
  short unsigned int D.26540;
  unsigned int D.26543;
  int D.26544;
  int D.26545;
  unsigned int D.26546;
  unsigned int D.26547;
  struct MonoMethod * default_ghc.239;
  unsigned int D.26553;
  int D.26554;
  <unnamed-unsigned:1> D.26555;
  <unnamed-unsigned:1> D.26556;
  <unnamed-unsigned:1> D.26557;
  struct MonoClass * D.26563;
  struct MonoType * D.26564;
  int D.26565;
  _Bool D.26566;
  int D.26567;
  int D.26570;
  <unnamed-unsigned:1> D.26578;
  int D.26579;
  unsigned char D.26580;
  <unnamed-unsigned:1> D.26581;
  <unnamed-unsigned:1> D.26582;
  unsigned char D.26583;
  int D.26586;
  struct MonoImage * D.26592;
  short unsigned int D.26597;
  int D.26598;
  int D.26599;
  struct MonoMethod * * D.26604;
  unsigned int i.240;
  unsigned int D.26606;
  struct MonoMethod * * D.26607;
  short unsigned int D.26608;
  int D.26609;
  int D.26610;
  int D.19923;
  int iftmp.241;
  int D.19919;
  const char[7] * D.26616;
  unsigned char D.26617;
  int D.26618;
  unsigned char D.26619;
  int D.26620;
  _Bool D.26621;
  _Bool D.26622;
  _Bool D.26623;
  const unsigned char * D.26626;
  unsigned char D.26627;
  int D.26628;
  const unsigned char * D.26629;
  unsigned char D.26630;
  int D.26631;
  _Bool D.26632;
  _Bool D.26633;
  const unsigned char * D.26636;
  unsigned char D.26637;
  int D.26638;
  const unsigned char * D.26639;
  unsigned char D.26640;
  int D.26641;
  _Bool D.26642;
  _Bool D.26643;
  const unsigned char * D.26646;
  unsigned char D.26647;
  int D.26648;
  const unsigned char * D.26649;
  unsigned char D.26650;
  int D.26651;
  const char * D.26653;
  unsigned int i.242;
  unsigned char D.26659;
  struct MonoLoaderError * D.26662;
  int D.26664;
  struct MonoLoaderError * D.26669;
  int D.26671;
  <unnamed type> D.26675;
  struct MonoLoaderError * D.26678;
  struct MonoLoaderError * D.26683;
  int D.26686;
  gchar * D.26689;
  void (*<T1def>) (struct MonoClass *) mono_debugger_class_init_func.243;
  int i;
  struct MonoCachedClassInfo cached_info;
  gboolean has_cached_info;
  void leave = <<< error >>>;

  try
    {
      D.26415 = class == 0B;
      D.26416 = (long int) D.26415;
      D.26417 = __builtin_expect (D.26416, 0);
      if (D.26417 != 0) goto <D.26418>; else goto <D.26419>;
      <D.26418>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "class.c", 4915, "class");
      <D.26419>:
      D.26422 = BIT_FIELD_REF <*class, 8, 160>;
      D.26423 = D.26422 & 1;
      if (D.26423 != 0) goto <D.26420>; else goto <D.26424>;
      <D.26424>:
      D.26425 = class->exception_type;
      if (D.26425 != 0) goto <D.26420>; else goto <D.26421>;
      <D.26420>:
      D.26425 = class->exception_type;
      D.26427 = D.26425 == 0;
      D.26426 = (mono_bool) D.26427;
      return D.26426;
      <D.26421>:
      mono_loader_lock ();
      D.26422 = BIT_FIELD_REF <*class, 8, 160>;
      D.26423 = D.26422 & 1;
      if (D.26423 != 0) goto <D.26428>; else goto <D.26430>;
      <D.26430>:
      D.26425 = class->exception_type;
      if (D.26425 != 0) goto <D.26428>; else goto <D.26429>;
      <D.26428>:
      mono_loader_unlock ();
      D.26425 = class->exception_type;
      D.26427 = D.26425 == 0;
      D.26426 = (mono_bool) D.26427;
      return D.26426;
      <D.26429>:
      D.26422 = BIT_FIELD_REF <*class, 8, 160>;
      D.26431 = D.26422 & 2;
      if (D.26431 != 0) goto <D.26432>; else goto <D.26433>;
      <D.26432>:
      D.26434 = monoeg_strdup ("Recursive type definition detected");
      mono_class_set_failure (class, 7, D.26434);
      goto leave;
      <D.26433>:
      class->init_pending = 1;
      D.26435 = mono_verifier_is_enabled_for_class (class);
      if (D.26435 != 0) goto <D.26436>; else goto <D.26437>;
      <D.26436>:
      D.26438 = mono_verifier_verify_class (class);
      if (D.26438 == 0) goto <D.26439>; else goto <D.26440>;
      <D.26439>:
      D.26441 = class->image;
      D.26442 = D.26441->assembly_name;
      D.26443 = class->name;
      D.26441 = class->image;
      D.26444 = concat_two_strings_with_zero (D.26441, D.26443, D.26442);
      mono_class_set_failure (class, 7, D.26444);
      goto leave;
      <D.26440>:
      <D.26437>:
      D.26445 = class->byval_arg.type;
      D.26446 = D.26445 == 20;
      D.26447 = D.26445 == 29;
      D.26448 = D.26446 | D.26447;
      if (D.26448 != 0) goto <D.26449>; else goto <D.26450>;
      <D.26449>:
      {
        struct MonoClass * element_class;

        element_class = class->element_class;
        D.26451 = BIT_FIELD_REF <*element_class, 8, 160>;
        D.26452 = D.26451 & 1;
        if (D.26452 == 0) goto <D.26453>; else goto <D.26454>;
        <D.26453>:
        mono_class_init (element_class);
        <D.26454>:
        D.26455 = element_class->exception_type;
        if (D.26455 != 0) goto <D.26456>; else goto <D.26457>;
        <D.26456>:
        mono_class_set_failure (class, 7, 0B);
        goto leave;
        <D.26457>:
      }
      <D.26450>:
      D.26458 = mono_is_security_manager_active ();
      if (D.26458 != 0) goto <D.26459>; else goto <D.26460>;
      <D.26459>:
      D.26461 = class->parent;
      if (D.26461 != 0B) goto <D.26462>; else goto <D.26463>;
      <D.26462>:
      D.26461 = class->parent;
      D.26464 = D.26461->flags;
      D.26465 = D.26464 & 262144;
      if (D.26465 != 0) goto <D.26466>; else goto <D.26467>;
      <D.26466>:
      D.26461 = class->parent;
      mono_secman_inheritancedemand_class (class, D.26461);
      <D.26467>:
      <D.26463>:
      <D.26460>:
      D.26468 = mono_stats.initialized_class_count;
      D.26469 = D.26468 + 1;
      mono_stats.initialized_class_count = D.26469;
      D.26470 = class->generic_class;
      if (D.26470 != 0B) goto <D.26471>; else goto <D.26472>;
      <D.26471>:
      D.26470 = class->generic_class;
      D.26473 = BIT_FIELD_REF <*D.26470, 8, 96>;
      D.26474 = D.26473 & 1;
      if (D.26474 == 0) goto <D.26475>; else goto <D.26476>;
      <D.26475>:
      {
        struct MonoClass * gklass;

        D.26470 = class->generic_class;
        gklass = D.26470->container_class;
        D.26477 = mono_stats.generic_class_count;
        D.26478 = D.26477 + 1;
        mono_stats.generic_class_count = D.26478;
        class->method = gklass->method;
        class->field = gklass->field;
        mono_class_init (gklass);
        D.26479 = gklass->exception_type;
        if (D.26479 == 0) goto <D.26480>; else goto <D.26481>;
        <D.26480>:
        mono_class_setup_methods (gklass);
        <D.26481>:
        D.26479 = gklass->exception_type;
        if (D.26479 != 0) goto <D.26482>; else goto <D.26483>;
        <D.26482>:
        D.26484 = monoeg_g_strdup_printf ("Generic Type Defintion failed to init");
        mono_class_set_failure (class, 7, D.26484);
        goto leave;
        <D.26483>:
        D.26487 = class->flags;
        D.26488 = D.26487 & 32;
        if (D.26488 != 0) goto <D.26485>; else goto <D.26489>;
        <D.26489>:
        D.26490 = class->byval_arg.type;
        if (D.26490 == 19) goto <D.26485>; else goto <D.26491>;
        <D.26491>:
        D.26490 = class->byval_arg.type;
        if (D.26490 == 30) goto <D.26485>; else goto <D.26486>;
        <D.26485>:
        D.26492 = mono_get_unique_iid (class);
        D.26493 = (short unsigned int) D.26492;
        class->interface_id = D.26493;
        <D.26486>:
      }
      <D.26476>:
      <D.26472>:
      D.26461 = class->parent;
      if (D.26461 != 0B) goto <D.26494>; else goto <D.26495>;
      <D.26494>:
      D.26461 = class->parent;
      D.26496 = BIT_FIELD_REF <*D.26461, 8, 160>;
      D.26497 = D.26496 & 1;
      if (D.26497 == 0) goto <D.26498>; else goto <D.26499>;
      <D.26498>:
      D.26461 = class->parent;
      mono_class_init (D.26461);
      <D.26499>:
      <D.26495>:
      has_cached_info = mono_class_get_cached_class_info (class, &cached_info);
      D.26470 = class->generic_class;
      if (D.26470 != 0B) goto <D.26500>; else goto <D.26502>;
      <D.26502>:
      D.26441 = class->image;
      D.26503 = BIT_FIELD_REF <*D.26441, 8, 128>;
      D.26504 = D.26503 & 8;
      if (D.26504 != 0) goto <D.26500>; else goto <D.26505>;
      <D.26505>:
      D.26506 = class->type_token;
      if (D.26506 == 0) goto <D.26500>; else goto <D.26507>;
      <D.26507>:
      if (has_cached_info != 0) goto <D.26508>; else goto <D.26501>;
      <D.26508>:
      D.26509 = BIT_FIELD_REF <cached_info, 8, 32>;
      D.26510 = D.26509 & 8;
      if (D.26510 == 0) goto <D.26500>; else goto <D.26501>;
      <D.26500>:
      class->nested_classes_inited = 1;
      <D.26501>:
      if (has_cached_info != 0) goto <D.26511>; else goto <D.26512>;
      <D.26511>:
      D.26513 = cached_info.instance_size;
      D.26514 = (int) D.26513;
      class->instance_size = D.26514;
      D.26515 = cached_info.class_size;
      D.26516 = (int) D.26515;
      class->sizes.class_size = D.26516;
      D.26517 = cached_info.packing_size;
      D.26518 = (unsigned char) D.26517;
      D.26519 = (<unnamed-unsigned:4>) D.26518;
      class->packing_size = D.26519;
      D.26520 = cached_info.min_align;
      D.26521 = (unsigned char) D.26520;
      class->min_align = D.26521;
      D.26522 = cached_info.blittable;
      class->blittable = D.26522;
      D.26523 = cached_info.has_references;
      class->has_references = D.26523;
      D.26524 = cached_info.has_static_refs;
      class->has_static_refs = D.26524;
      D.26525 = cached_info.no_special_static_fields;
      class->no_special_static_fields = D.26525;
      goto <D.26526>;
      <D.26512>:
      D.26422 = BIT_FIELD_REF <*class, 8, 160>;
      D.26527 = D.26422 & 4;
      if (D.26527 == 0) goto <D.26528>; else goto <D.26529>;
      <D.26528>:
      mono_class_setup_fields (class);
      D.26425 = class->exception_type;
      if (D.26425 != 0) goto leave; else goto <D.26530>;
      <D.26530>:
      D.26531 = mono_loader_get_last_error ();
      if (D.26531 != 0B) goto leave; else goto <D.26532>;
      <D.26532>:
      <D.26529>:
      <D.26526>:
      D.26533 = class->rank;
      if (D.26533 != 0) goto <D.26534>; else goto <D.26535>;
      <D.26534>:
      D.26533 = class->rank;
      if (D.26533 > 1) goto <D.26537>; else goto <D.26538>;
      <D.26537>:
      iftmp.238 = 5;
      goto <D.26539>;
      <D.26538>:
      iftmp.238 = 4;
      <D.26539>:
      class->method.count = iftmp.238;
      D.26540 = class->interface_count;
      if (D.26540 != 0) goto <D.26541>; else goto <D.26542>;
      <D.26541>:
      {
        int count_generic;

        count_generic = generic_array_methods (class);
        D.26543 = class->method.count;
        D.26540 = class->interface_count;
        D.26544 = (int) D.26540;
        D.26545 = D.26544 * count_generic;
        D.26546 = (unsigned int) D.26545;
        D.26547 = D.26543 + D.26546;
        class->method.count = D.26547;
      }
      <D.26542>:
      <D.26535>:
      mono_class_setup_supertypes (class);
      default_ghc.239 = default_ghc;
      if (default_ghc.239 == 0B) goto <D.26549>; else goto <D.26550>;
      <D.26549>:
      initialize_object_slots (class);
      <D.26550>:
      if (has_cached_info != 0) goto <D.26551>; else goto <D.26552>;
      <D.26551>:
      D.26553 = cached_info.vtable_size;
      D.26554 = (int) D.26553;
      class->vtable_size = D.26554;
      D.26555 = cached_info.has_finalize;
      class->has_finalize = D.26555;
      class->has_finalize_inited = 1;
      D.26556 = cached_info.ghcimpl;
      class->ghcimpl = D.26556;
      D.26557 = cached_info.has_cctor;
      class->has_cctor = D.26557;
      goto <D.26558>;
      <D.26552>:
      D.26533 = class->rank;
      if (D.26533 == 1) goto <D.26561>; else goto <D.26559>;
      <D.26561>:
      D.26490 = class->byval_arg.type;
      if (D.26490 == 29) goto <D.26562>; else goto <D.26559>;
      <D.26562>:
      {
        static int szarray_vtable_size[2] = {0};
        int slot;

        D.26563 = class->element_class;
        D.26564 = &D.26563->byval_arg;
        D.26565 = mono_type_is_reference (D.26564);
        D.26566 = D.26565 == 0;
        slot = (int) D.26566;
        D.26567 = szarray_vtable_size[slot];
        if (D.26567 == 0) goto <D.26568>; else goto <D.26569>;
        <D.26568>:
        mono_class_setup_vtable (class);
        D.26570 = class->vtable_size;
        szarray_vtable_size[slot] = D.26570;
        goto <D.26571>;
        <D.26569>:
        D.26567 = szarray_vtable_size[slot];
        class->vtable_size = D.26567;
        <D.26571>:
        class->has_finalize_inited = 1;
      }
      goto <D.26560>;
      <D.26559>:
      D.26470 = class->generic_class;
      if (D.26470 != 0B) goto <D.26574>; else goto <D.26572>;
      <D.26574>:
      D.26487 = class->flags;
      D.26488 = D.26487 & 32;
      if (D.26488 == 0) goto <D.26575>; else goto <D.26572>;
      <D.26575>:
      D.26490 = class->byval_arg.type;
      if (D.26490 != 19) goto <D.26576>; else goto <D.26572>;
      <D.26576>:
      D.26490 = class->byval_arg.type;
      if (D.26490 != 30) goto <D.26577>; else goto <D.26572>;
      <D.26577>:
      {
        struct MonoClass * gklass;

        D.26470 = class->generic_class;
        gklass = D.26470->container_class;
        D.26578 = gklass->ghcimpl;
        class->ghcimpl = D.26578;
        D.26579 = mono_class_has_finalizer (gklass);
        D.26580 = (unsigned char) D.26579;
        D.26581 = (<unnamed-unsigned:1>) D.26580;
        class->has_finalize = D.26581;
        class->has_finalize_inited = 1;
        D.26582 = gklass->has_cctor;
        class->has_cctor = D.26582;
        mono_class_setup_vtable (gklass);
        D.26583 = gklass->exception_type;
        if (D.26583 != 0) goto <D.26584>; else goto <D.26585>;
        <D.26584>:
        mono_class_set_failure (class, 7, 0B);
        goto leave;
        <D.26585>:
        D.26586 = gklass->vtable_size;
        class->vtable_size = D.26586;
      }
      goto <D.26573>;
      <D.26572>:
      D.26487 = class->flags;
      D.26488 = D.26487 & 32;
      if (D.26488 == 0) goto <D.26590>; else goto <D.26587>;
      <D.26590>:
      D.26490 = class->byval_arg.type;
      if (D.26490 != 19) goto <D.26591>; else goto <D.26587>;
      <D.26591>:
      D.26490 = class->byval_arg.type;
      if (D.26490 != 30) goto <D.26588>; else goto <D.26587>;
      <D.26587>:
      D.26441 = class->image;
      D.26592 = mono_defaults.corlib;
      if (D.26441 != D.26592) goto <D.26588>; else goto <D.26589>;
      <D.26588>:
      {
        struct MonoMethod * cmethod;

        cmethod = 0B;
        D.26506 = class->type_token;
        if (D.26506 != 0) goto <D.26593>; else goto <D.26594>;
        <D.26593>:
        cmethod = find_method_in_metadata (class, ".cctor", 0, 2048);
        if (cmethod != 0B) goto <D.26595>; else goto <D.26596>;
        <D.26595>:
        D.26597 = cmethod->flags;
        D.26598 = (int) D.26597;
        D.26599 = D.26598 & 2048;
        if (D.26599 != 0) goto <D.26600>; else goto <D.26601>;
        <D.26600>:
        class->has_cctor = 1;
        <D.26601>:
        <D.26596>:
        goto <D.26602>;
        <D.26594>:
        mono_class_setup_methods (class);
        D.26425 = class->exception_type;
        if (D.26425 != 0) goto leave; else goto <D.26603>;
        <D.26603>:
        i = 0;
        goto <D.19926>;
        <D.19925>:
        {
          struct MonoMethod * method;

          D.26604 = class->methods;
          i.240 = (unsigned int) i;
          D.26606 = i.240 * 4;
          D.26607 = D.26604 + D.26606;
          method = *D.26607;
          D.26608 = method->flags;
          D.26609 = (int) D.26608;
          D.26610 = D.26609 & 2048;
          if (D.26610 != 0) goto <D.26611>; else goto <D.26612>;
          <D.26611>:
          {
            size_t __s1_len;
            size_t __s2_len;

            __s1_len = 6;
            if (__s1_len <= 3) goto <D.26614>; else goto <D.26615>;
            <D.26614>:
            {
              const unsigned char * __s2;
              int __result;

              __s2 = method->name;
              D.26616 = ".cctor";
              D.26617 = MEM[(const unsigned char *)D.26616];
              D.26618 = (int) D.26617;
              D.26619 = *__s2;
              D.26620 = (int) D.26619;
              __result = D.26618 - D.26620;
              {
                D.26621 = __s1_len != 0;
                D.26622 = __result == 0;
                D.26623 = D.26621 & D.26622;
                if (D.26623 != 0) goto <D.26624>; else goto <D.26625>;
                <D.26624>:
                D.26626 = &MEM[(void *)".cctor" + 1B];
                D.26627 = *D.26626;
                D.26628 = (int) D.26627;
                D.26629 = __s2 + 1;
                D.26630 = *D.26629;
                D.26631 = (int) D.26630;
                __result = D.26628 - D.26631;
                D.26632 = __s1_len > 1;
                D.26622 = __result == 0;
                D.26633 = D.26632 & D.26622;
                if (D.26633 != 0) goto <D.26634>; else goto <D.26635>;
                <D.26634>:
                D.26636 = &MEM[(void *)".cctor" + 2B];
                D.26637 = *D.26636;
                D.26638 = (int) D.26637;
                D.26639 = __s2 + 2;
                D.26640 = *D.26639;
                D.26641 = (int) D.26640;
                __result = D.26638 - D.26641;
                D.26642 = __s1_len > 2;
                D.26622 = __result == 0;
                D.26643 = D.26642 & D.26622;
                if (D.26643 != 0) goto <D.26644>; else goto <D.26645>;
                <D.26644>:
                D.26646 = &MEM[(void *)".cctor" + 3B];
                D.26647 = *D.26646;
                D.26648 = (int) D.26647;
                D.26649 = __s2 + 3;
                D.26650 = *D.26649;
                D.26651 = (int) D.26650;
                __result = D.26648 - D.26651;
                <D.26645>:
                <D.26635>:
                <D.26625>:
              }
              D.19919 = __result;
            }
            iftmp.241 = D.19919;
            goto <D.26652>;
            <D.26615>:
            D.26653 = method->name;
            iftmp.241 = __builtin_strcmp (".cctor", D.26653);
            <D.26652>:
            D.19923 = iftmp.241;
          }
          if (D.19923 == 0) goto <D.26654>; else goto <D.26655>;
          <D.26654>:
          class->has_cctor = 1;
          goto <D.19924>;
          <D.26655>:
          <D.26612>:
        }
        i = i + 1;
        <D.19926>:
        i.242 = (unsigned int) i;
        D.26543 = class->method.count;
        if (i.242 < D.26543) goto <D.19925>; else goto <D.19924>;
        <D.19924>:
        <D.26602>:
      }
      <D.26589>:
      <D.26573>:
      <D.26560>:
      <D.26558>:
      D.26461 = class->parent;
      if (D.26461 != 0B) goto <D.26657>; else goto <D.26658>;
      <D.26657>:
      {
        int first_iface_slot;

        D.26461 = class->parent;
        mono_class_init (D.26461);
        D.26461 = class->parent;
        D.26659 = D.26461->exception_type;
        if (D.26659 != 0) goto <D.26660>; else goto <D.26661>;
        <D.26660>:
        mono_class_set_failure (class, 7, 0B);
        goto leave;
        <D.26661>:
        D.26662 = mono_loader_get_last_error ();
        if (D.26662 != 0B) goto leave; else goto <D.26663>;
        <D.26663>:
        D.26461 = class->parent;
        D.26664 = D.26461->vtable_size;
        if (D.26664 == 0) goto <D.26665>; else goto <D.26666>;
        <D.26665>:
        D.26461 = class->parent;
        mono_class_setup_vtable (D.26461);
        D.26461 = class->parent;
        D.26659 = D.26461->exception_type;
        if (D.26659 != 0) goto <D.26667>; else goto <D.26668>;
        <D.26667>:
        mono_class_set_failure (class, 7, 0B);
        goto leave;
        <D.26668>:
        D.26669 = mono_loader_get_last_error ();
        if (D.26669 != 0B) goto leave; else goto <D.26670>;
        <D.26670>:
        <D.26666>:
        D.26461 = class->parent;
        first_iface_slot = D.26461->vtable_size;
        D.26671 = mono_class_need_stelemref_method (class);
        if (D.26671 != 0) goto <D.26672>; else goto <D.26673>;
        <D.26672>:
        first_iface_slot = first_iface_slot + 1;
        <D.26673>:
        setup_interface_offsets (class, first_iface_slot, 1);
      }
      goto <D.26674>;
      <D.26658>:
      setup_interface_offsets (class, 0, 1);
      <D.26674>:
      D.26675 = mono_security_get_mode ();
      if (D.26675 == 1) goto <D.26676>; else goto <D.26677>;
      <D.26676>:
      mono_security_core_clr_check_inheritance (class);
      <D.26677>:
      D.26678 = mono_loader_get_last_error ();
      if (D.26678 != 0B) goto <D.26679>; else goto <D.26680>;
      <D.26679>:
      D.26425 = class->exception_type;
      if (D.26425 == 0) goto <D.26681>; else goto <D.26682>;
      <D.26681>:
      D.26683 = mono_loader_get_last_error ();
      set_failure_from_loader_error (class, D.26683);
      <D.26682>:
      mono_loader_clear_error ();
      <D.26680>:
      D.26470 = class->generic_class;
      if (D.26470 != 0B) goto <D.26684>; else goto <D.26685>;
      <D.26684>:
      D.26686 = mono_verifier_class_is_valid_generic_instantiation (class);
      if (D.26686 == 0) goto <D.26687>; else goto <D.26688>;
      <D.26687>:
      D.26689 = monoeg_strdup ("Invalid generic instantiation");
      mono_class_set_failure (class, 7, D.26689);
      <D.26688>:
      <D.26685>:
      goto leave;
      leave:
      mono_memory_barrier ();
      class->inited = 1;
      class->init_pending = 0;
      mono_loader_unlock ();
      mono_debugger_class_init_func.243 = mono_debugger_class_init_func;
      if (mono_debugger_class_init_func.243 != 0B) goto <D.26691>; else goto <D.26692>;
      <D.26691>:
      mono_debugger_class_init_func.243 = mono_debugger_class_init_func;
      mono_debugger_class_init_func.243 (class);
      <D.26692>:
      D.26425 = class->exception_type;
      D.26427 = D.26425 == 0;
      D.26426 = (mono_bool) D.26427;
      return D.26426;
    }
  finally
    {
      cached_info = {CLOBBER};
    }
}


mono_get_unique_iid (struct MonoClass * class)
{
  int iftmp.244;
  unsigned int D.26698;
  unsigned int D.26699;
  unsigned char D.26701;
  _Bool D.26704;
  long int D.26705;
  long int D.26706;
  struct MonoBitSet * global_interface_bitset.245;
  struct MonoBitSet * global_interface_bitset.246;
  unsigned int D.26715;
  int D.26716;
  unsigned int D.26717;
  unsigned int iid.247;
  struct MonoGenericClass * D.26719;
  struct MonoImage * D.26722;
  struct MonoBitSet * D.26723;
  unsigned int D.26726;
  int D.26729;
  unsigned int D.26730;
  struct MonoBitSet * D.26732;
  int mono_print_vtable.248;
  struct MonoType * D.26736;
  struct MonoGenericInst * D.26740;
  unsigned char D.26741;
  unsigned char D.26742;
  unsigned int D.26744;
  _Bool D.26745;
  long int D.26746;
  long int D.26747;
  char * D.26750;
  _Bool D.26751;
  long int D.26752;
  long int D.26753;
  guint D.26756;
  int iid;

  D.26698 = class->flags;
  D.26699 = D.26698 & 32;
  if (D.26699 == 0) goto <D.26700>; else goto <D.26696>;
  <D.26700>:
  D.26701 = class->byval_arg.type;
  if (D.26701 != 19) goto <D.26702>; else goto <D.26696>;
  <D.26702>:
  D.26701 = class->byval_arg.type;
  if (D.26701 != 30) goto <D.26703>; else goto <D.26696>;
  <D.26703>:
  iftmp.244 = 1;
  goto <D.26697>;
  <D.26696>:
  iftmp.244 = 0;
  <D.26697>:
  D.26704 = iftmp.244 != 0;
  D.26705 = (long int) D.26704;
  D.26706 = __builtin_expect (D.26705, 0);
  if (D.26706 != 0) goto <D.26707>; else goto <D.26708>;
  <D.26707>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "class.c", 2592, "MONO_CLASS_IS_INTERFACE (class)");
  <D.26708>:
  global_interface_bitset.245 = global_interface_bitset;
  if (global_interface_bitset.245 == 0B) goto <D.26710>; else goto <D.26711>;
  <D.26710>:
  global_interface_bitset.246 = mono_bitset_new (128, 0);
  global_interface_bitset = global_interface_bitset.246;
  <D.26711>:
  global_interface_bitset.245 = global_interface_bitset;
  iid = mono_bitset_find_first_unset (global_interface_bitset.245, -1);
  if (iid < 0) goto <D.26713>; else goto <D.26714>;
  <D.26713>:
  {
    int old_size;
    struct MonoBitSet * new_set;

    global_interface_bitset.245 = global_interface_bitset;
    D.26715 = mono_bitset_size (global_interface_bitset.245);
    old_size = (int) D.26715;
    D.26716 = old_size * 2;
    D.26717 = (unsigned int) D.26716;
    global_interface_bitset.245 = global_interface_bitset;
    new_set = mono_bitset_clone (global_interface_bitset.245, D.26717);
    global_interface_bitset.245 = global_interface_bitset;
    mono_bitset_free (global_interface_bitset.245);
    global_interface_bitset = new_set;
    iid = old_size;
  }
  <D.26714>:
  iid.247 = (unsigned int) iid;
  global_interface_bitset.245 = global_interface_bitset;
  mono_bitset_set (global_interface_bitset.245, iid.247);
  D.26719 = class->generic_class;
  if (D.26719 == 0B) goto <D.26720>; else goto <D.26721>;
  <D.26720>:
  D.26722 = class->image;
  D.26723 = D.26722->interface_bitset;
  if (D.26723 != 0B) goto <D.26724>; else goto <D.26725>;
  <D.26724>:
  iid.247 = (unsigned int) iid;
  D.26722 = class->image;
  D.26723 = D.26722->interface_bitset;
  D.26726 = mono_bitset_size (D.26723);
  if (iid.247 >= D.26726) goto <D.26727>; else goto <D.26728>;
  <D.26727>:
  {
    struct MonoBitSet * new_set;

    D.26729 = iid + 1;
    D.26730 = (unsigned int) D.26729;
    D.26722 = class->image;
    D.26723 = D.26722->interface_bitset;
    new_set = mono_bitset_clone (D.26723, D.26730);
    D.26722 = class->image;
    D.26723 = D.26722->interface_bitset;
    mono_bitset_free (D.26723);
    D.26722 = class->image;
    D.26722->interface_bitset = new_set;
  }
  <D.26728>:
  goto <D.26731>;
  <D.26725>:
  D.26722 = class->image;
  D.26729 = iid + 1;
  D.26730 = (unsigned int) D.26729;
  D.26732 = mono_bitset_new (D.26730, 0);
  D.26722->interface_bitset = D.26732;
  <D.26731>:
  iid.247 = (unsigned int) iid;
  D.26722 = class->image;
  D.26723 = D.26722->interface_bitset;
  mono_bitset_set (D.26723, iid.247);
  <D.26721>:
  mono_print_vtable.248 = mono_print_vtable;
  if (mono_print_vtable.248 != 0) goto <D.26734>; else goto <D.26735>;
  <D.26734>:
  {
    int generic_id;
    char * type_name;

    D.26736 = &class->byval_arg;
    type_name = mono_type_full_name (D.26736);
    D.26719 = class->generic_class;
    if (D.26719 != 0B) goto <D.26739>; else goto <D.26737>;
    <D.26739>:
    D.26719 = class->generic_class;
    D.26740 = D.26719->context.class_inst;
    D.26741 = BIT_FIELD_REF <*D.26740, 8, 48>;
    D.26742 = D.26741 & 64;
    if (D.26742 == 0) goto <D.26743>; else goto <D.26737>;
    <D.26743>:
    D.26719 = class->generic_class;
    D.26740 = D.26719->context.class_inst;
    D.26744 = D.26740->id;
    generic_id = (int) D.26744;
    D.26745 = generic_id == 0;
    D.26746 = (long int) D.26745;
    D.26747 = __builtin_expect (D.26746, 0);
    if (D.26747 != 0) goto <D.26748>; else goto <D.26749>;
    <D.26748>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "class.c", 2627, "generic_id != 0");
    <D.26749>:
    goto <D.26738>;
    <D.26737>:
    generic_id = 0;
    <D.26738>:
    D.26722 = class->image;
    D.26750 = D.26722->name;
    printf ("Interface: assigned id %d to %s|%s|%d\n", iid, D.26750, type_name, generic_id);
    monoeg_g_free (type_name);
  }
  <D.26735>:
  D.26751 = iid > 65535;
  D.26752 = (long int) D.26751;
  D.26753 = __builtin_expect (D.26752, 0);
  if (D.26753 != 0) goto <D.26754>; else goto <D.26755>;
  <D.26754>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "class.c", 2636, "iid <= 65535");
  <D.26755>:
  D.26756 = (guint) iid;
  return D.26756;
}


mono_class_get_cached_class_info (struct MonoClass * klass, struct MonoCachedClassInfo * res)
{
  gboolean (*<T1e26>) (struct MonoClass *, struct MonoCachedClassInfo *) get_cached_class_info.249;
  gboolean D.26761;

  get_cached_class_info.249 = get_cached_class_info;
  if (get_cached_class_info.249 == 0B) goto <D.26759>; else goto <D.26760>;
  <D.26759>:
  D.26761 = 0;
  return D.26761;
  <D.26760>:
  get_cached_class_info.249 = get_cached_class_info;
  D.26761 = get_cached_class_info.249 (klass, res);
  return D.26761;
}


initialize_object_slots (struct MonoClass * class)
{
  struct MonoMethod * default_ghc.250;
  struct MonoClass * D.26766;
  struct MonoMethod * * D.26769;
  unsigned int i.251;
  unsigned int D.26771;
  struct MonoMethod * * D.26772;
  int D.19770;
  int iftmp.252;
  int D.19769;
  const char[12] * D.26776;
  unsigned char D.26777;
  int D.26778;
  unsigned char D.26779;
  int D.26780;
  _Bool D.26781;
  _Bool D.26782;
  _Bool D.26783;
  const unsigned char * D.26786;
  unsigned char D.26787;
  int D.26788;
  const unsigned char * D.26789;
  unsigned char D.26790;
  int D.26791;
  _Bool D.26792;
  _Bool D.26793;
  const unsigned char * D.26796;
  unsigned char D.26797;
  int D.26798;
  const unsigned char * D.26799;
  unsigned char D.26800;
  int D.26801;
  _Bool D.26802;
  _Bool D.26803;
  const unsigned char * D.26806;
  unsigned char D.26807;
  int D.26808;
  const unsigned char * D.26809;
  unsigned char D.26810;
  int D.26811;
  const char * D.26813;
  int D.19779;
  int iftmp.253;
  int D.19778;
  const char[9] * D.26820;
  unsigned char D.26821;
  int D.26822;
  unsigned char D.26823;
  int D.26824;
  _Bool D.26825;
  _Bool D.26826;
  _Bool D.26827;
  const unsigned char * D.26830;
  unsigned char D.26831;
  int D.26832;
  const unsigned char * D.26833;
  unsigned char D.26834;
  int D.26835;
  _Bool D.26836;
  _Bool D.26837;
  const unsigned char * D.26840;
  unsigned char D.26841;
  int D.26842;
  const unsigned char * D.26843;
  unsigned char D.26844;
  int D.26845;
  _Bool D.26846;
  _Bool D.26847;
  const unsigned char * D.26850;
  unsigned char D.26851;
  int D.26852;
  const unsigned char * D.26853;
  unsigned char D.26854;
  int D.26855;
  int D.26859;
  int ghc_slot.254;
  _Bool D.26861;
  long int D.26862;
  long int D.26863;
  unsigned int ghc_slot.255;
  unsigned int D.26867;
  struct MonoMethod * * D.26868;
  struct MonoMethod * default_ghc.256;
  int finalize_slot.257;
  _Bool D.26871;
  long int D.26872;
  long int D.26873;
  unsigned int finalize_slot.258;
  unsigned int D.26877;
  struct MonoMethod * * D.26878;
  struct MonoMethod * default_finalize.259;
  int i;

  default_ghc.250 = default_ghc;
  if (default_ghc.250 != 0B) goto <D.26764>; else goto <D.26765>;
  <D.26764>:
  return;
  <D.26765>:
  D.26766 = mono_defaults.object_class;
  if (D.26766 == class) goto <D.26767>; else goto <D.26768>;
  <D.26767>:
  mono_class_setup_vtable (class);
  i = 0;
  goto <D.19781>;
  <D.19780>:
  {
    struct MonoMethod * cm;

    D.26769 = class->vtable;
    i.251 = (unsigned int) i;
    D.26771 = i.251 * 4;
    D.26772 = D.26769 + D.26771;
    cm = *D.26772;
    {
      size_t __s1_len;
      size_t __s2_len;

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

        __s2 = cm->name;
        D.26776 = "GetHashCode";
        D.26777 = MEM[(const unsigned char *)D.26776];
        D.26778 = (int) D.26777;
        D.26779 = *__s2;
        D.26780 = (int) D.26779;
        __result = D.26778 - D.26780;
        {
          D.26781 = __s2_len != 0;
          D.26782 = __result == 0;
          D.26783 = D.26781 & D.26782;
          if (D.26783 != 0) goto <D.26784>; else goto <D.26785>;
          <D.26784>:
          D.26786 = &MEM[(void *)"GetHashCode" + 1B];
          D.26787 = *D.26786;
          D.26788 = (int) D.26787;
          D.26789 = __s2 + 1;
          D.26790 = *D.26789;
          D.26791 = (int) D.26790;
          __result = D.26788 - D.26791;
          D.26792 = __s2_len > 1;
          D.26782 = __result == 0;
          D.26793 = D.26792 & D.26782;
          if (D.26793 != 0) goto <D.26794>; else goto <D.26795>;
          <D.26794>:
          D.26796 = &MEM[(void *)"GetHashCode" + 2B];
          D.26797 = *D.26796;
          D.26798 = (int) D.26797;
          D.26799 = __s2 + 2;
          D.26800 = *D.26799;
          D.26801 = (int) D.26800;
          __result = D.26798 - D.26801;
          D.26802 = __s2_len > 2;
          D.26782 = __result == 0;
          D.26803 = D.26802 & D.26782;
          if (D.26803 != 0) goto <D.26804>; else goto <D.26805>;
          <D.26804>:
          D.26806 = &MEM[(void *)"GetHashCode" + 3B];
          D.26807 = *D.26806;
          D.26808 = (int) D.26807;
          D.26809 = __s2 + 3;
          D.26810 = *D.26809;
          D.26811 = (int) D.26810;
          __result = D.26808 - D.26811;
          <D.26805>:
          <D.26795>:
          <D.26785>:
        }
        D.19769 = __result;
      }
      iftmp.252 = -D.19769;
      goto <D.26812>;
      <D.26775>:
      D.26813 = cm->name;
      iftmp.252 = __builtin_strcmp (D.26813, "GetHashCode");
      <D.26812>:
      D.19770 = iftmp.252;
    }
    if (D.19770 == 0) goto <D.26814>; else goto <D.26815>;
    <D.26814>:
    ghc_slot = i;
    goto <D.26816>;
    <D.26815>:
    {
      size_t __s1_len;
      size_t __s2_len;

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

        __s2 = cm->name;
        D.26820 = "Finalize";
        D.26821 = MEM[(const unsigned char *)D.26820];
        D.26822 = (int) D.26821;
        D.26823 = *__s2;
        D.26824 = (int) D.26823;
        __result = D.26822 - D.26824;
        {
          D.26825 = __s2_len != 0;
          D.26826 = __result == 0;
          D.26827 = D.26825 & D.26826;
          if (D.26827 != 0) goto <D.26828>; else goto <D.26829>;
          <D.26828>:
          D.26830 = &MEM[(void *)"Finalize" + 1B];
          D.26831 = *D.26830;
          D.26832 = (int) D.26831;
          D.26833 = __s2 + 1;
          D.26834 = *D.26833;
          D.26835 = (int) D.26834;
          __result = D.26832 - D.26835;
          D.26836 = __s2_len > 1;
          D.26826 = __result == 0;
          D.26837 = D.26836 & D.26826;
          if (D.26837 != 0) goto <D.26838>; else goto <D.26839>;
          <D.26838>:
          D.26840 = &MEM[(void *)"Finalize" + 2B];
          D.26841 = *D.26840;
          D.26842 = (int) D.26841;
          D.26843 = __s2 + 2;
          D.26844 = *D.26843;
          D.26845 = (int) D.26844;
          __result = D.26842 - D.26845;
          D.26846 = __s2_len > 2;
          D.26826 = __result == 0;
          D.26847 = D.26846 & D.26826;
          if (D.26847 != 0) goto <D.26848>; else goto <D.26849>;
          <D.26848>:
          D.26850 = &MEM[(void *)"Finalize" + 3B];
          D.26851 = *D.26850;
          D.26852 = (int) D.26851;
          D.26853 = __s2 + 3;
          D.26854 = *D.26853;
          D.26855 = (int) D.26854;
          __result = D.26852 - D.26855;
          <D.26849>:
          <D.26839>:
          <D.26829>:
        }
        D.19778 = __result;
      }
      iftmp.253 = -D.19778;
      goto <D.26856>;
      <D.26819>:
      D.26813 = cm->name;
      iftmp.253 = __builtin_strcmp (D.26813, "Finalize");
      <D.26856>:
      D.19779 = iftmp.253;
    }
    if (D.19779 == 0) goto <D.26857>; else goto <D.26858>;
    <D.26857>:
    finalize_slot = i;
    <D.26858>:
    <D.26816>:
  }
  i = i + 1;
  <D.19781>:
  D.26859 = class->vtable_size;
  if (D.26859 > i) goto <D.19780>; else goto <D.19782>;
  <D.19782>:
  ghc_slot.254 = ghc_slot;
  D.26861 = ghc_slot.254 <= 0;
  D.26862 = (long int) D.26861;
  D.26863 = __builtin_expect (D.26862, 0);
  if (D.26863 != 0) goto <D.26864>; else goto <D.26865>;
  <D.26864>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "class.c", 4736, "ghc_slot > 0");
  <D.26865>:
  D.26769 = class->vtable;
  ghc_slot.254 = ghc_slot;
  ghc_slot.255 = (unsigned int) ghc_slot.254;
  D.26867 = ghc_slot.255 * 4;
  D.26868 = D.26769 + D.26867;
  default_ghc.256 = *D.26868;
  default_ghc = default_ghc.256;
  finalize_slot.257 = finalize_slot;
  D.26871 = finalize_slot.257 <= 0;
  D.26872 = (long int) D.26871;
  D.26873 = __builtin_expect (D.26872, 0);
  if (D.26873 != 0) goto <D.26874>; else goto <D.26875>;
  <D.26874>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "class.c", 4739, "finalize_slot > 0");
  <D.26875>:
  D.26769 = class->vtable;
  finalize_slot.257 = finalize_slot;
  finalize_slot.258 = (unsigned int) finalize_slot.257;
  D.26877 = finalize_slot.258 * 4;
  D.26878 = D.26769 + D.26877;
  default_finalize.259 = *D.26878;
  default_finalize = default_finalize.259;
  <D.26768>:
}


find_method_in_metadata (struct MonoClass * klass, const char * name, int param_count, int flags)
{
  unsigned int D.26881;
  unsigned int i.260;
  unsigned int D.26883;
  int D.26884;
  struct MonoImage * D.26885;
  int D.21384;
  unsigned int D.26886;
  const char * D.26887;
  unsigned int D.26890;
  unsigned int D.26891;
  short unsigned int D.26896;
  int D.26897;
  unsigned int D.26900;
  struct MonoMethod * D.26901;
  struct MonoMethod * res;
  int i;

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

    try
      {
        D.26881 = klass->method.first;
        i.260 = (unsigned int) i;
        D.26883 = D.26881 + i.260;
        D.26884 = (int) D.26883;
        D.26885 = klass->image;
        mono_metadata_decode_table_row (D.26885, 6, D.26884, &cols, 6);
        {
          size_t __s1_len;
          size_t __s2_len;

          D.26886 = cols[3];
          D.26885 = klass->image;
          D.26887 = mono_metadata_string_heap (D.26885, D.26886);
          D.21384 = __builtin_strcmp (D.26887, name);
        }
        if (D.21384 == 0) goto <D.26888>; else goto <D.26889>;
        <D.26888>:
        D.26881 = klass->method.first;
        i.260 = (unsigned int) i;
        D.26883 = D.26881 + i.260;
        D.26890 = D.26883 + 1;
        D.26891 = D.26890 | 100663296;
        D.26885 = klass->image;
        method = mono_get_method (D.26885, D.26891, klass);
        if (param_count == -1) goto <D.26892>; else goto <D.26893>;
        <D.26892>:
        res = method;
        goto <D.21385>;
        <D.26893>:
        sig = mono_method_signature (method);
        if (sig != 0B) goto <D.26894>; else goto <D.26895>;
        <D.26894>:
        D.26896 = sig->param_count;
        D.26897 = (int) D.26896;
        if (D.26897 == param_count) goto <D.26898>; else goto <D.26899>;
        <D.26898>:
        res = method;
        goto <D.21385>;
        <D.26899>:
        <D.26895>:
        <D.26889>:
      }
    finally
      {
        cols = {CLOBBER};
      }
  }
  i = i + 1;
  <D.21387>:
  i.260 = (unsigned int) i;
  D.26900 = klass->method.count;
  if (i.260 < D.26900) goto <D.21386>; else goto <D.21385>;
  <D.21385>:
  D.26901 = res;
  return D.26901;
}


mono_class_has_finalizer (struct MonoClass * klass)
{
  unsigned char D.26905;
  unsigned char D.26906;
  unsigned int D.26909;
  unsigned int D.26910;
  unsigned char D.26913;
  unsigned char D.26918;
  unsigned char D.26919;
  struct MonoClass * D.26924;
  unsigned char D.26926;
  unsigned char D.26927;
  unsigned char D.26931;
  struct MonoLoaderError * D.26933;
  struct MonoMethod * * D.26935;
  int finalize_slot.261;
  unsigned int finalize_slot.262;
  unsigned int D.26938;
  struct MonoMethod * * D.26939;
  int D.26942;
  _Bool D.26943;
  long int D.26944;
  long int D.26945;
  unsigned char D.26950;
  unsigned char D.26951;
  struct MonoMethod * default_finalize.263;
  gboolean D.26957;
  <unnamed-unsigned:1> D.26958;
  void leave = <<< error >>>;

  D.26905 = BIT_FIELD_REF <*klass, 8, 192>;
  D.26906 = D.26905 & 16;
  if (D.26906 == 0) goto <D.26907>; else goto <D.26908>;
  <D.26907>:
  {
    struct MonoClass * class;

    class = klass;
    mono_loader_lock ();
    D.26909 = class->flags;
    D.26910 = D.26909 & 32;
    if (D.26910 == 0) goto <D.26911>; else goto <D.26912>;
    <D.26911>:
    D.26913 = class->byval_arg.type;
    if (D.26913 != 19) goto <D.26914>; else goto <D.26915>;
    <D.26914>:
    D.26913 = class->byval_arg.type;
    if (D.26913 != 30) goto <D.26916>; else goto <D.26917>;
    <D.26916>:
    D.26918 = BIT_FIELD_REF <*class, 8, 160>;
    D.26919 = D.26918 & 8;
    if (D.26919 == 0) goto <D.26920>; else goto <D.26921>;
    <D.26920>:
    {
      struct MonoMethod * cmethod;

      cmethod = 0B;
      D.26924 = class->parent;
      if (D.26924 != 0B) goto <D.26925>; else goto <D.26922>;
      <D.26925>:
      D.26924 = class->parent;
      D.26926 = BIT_FIELD_REF <*D.26924, 8, 176>;
      D.26927 = D.26926 & 32;
      if (D.26927 != 0) goto <D.26928>; else goto <D.26922>;
      <D.26928>:
      class->has_finalize = 1;
      goto <D.26923>;
      <D.26922>:
      D.26924 = class->parent;
      if (D.26924 != 0B) goto <D.26929>; else goto <D.26930>;
      <D.26929>:
      mono_class_setup_vtable (class);
      D.26931 = class->exception_type;
      if (D.26931 != 0) goto leave; else goto <D.26932>;
      <D.26932>:
      D.26933 = mono_loader_get_last_error ();
      if (D.26933 != 0B) goto leave; else goto <D.26934>;
      <D.26934>:
      D.26935 = class->vtable;
      finalize_slot.261 = finalize_slot;
      finalize_slot.262 = (unsigned int) finalize_slot.261;
      D.26938 = finalize_slot.262 * 4;
      D.26939 = D.26935 + D.26938;
      cmethod = *D.26939;
      <D.26930>:
      if (cmethod != 0B) goto <D.26940>; else goto <D.26941>;
      <D.26940>:
      D.26942 = class->vtable_size;
      finalize_slot.261 = finalize_slot;
      D.26943 = D.26942 <= finalize_slot.261;
      D.26944 = (long int) D.26943;
      D.26945 = __builtin_expect (D.26944, 0);
      if (D.26945 != 0) goto <D.26946>; else goto <D.26947>;
      <D.26946>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "class.c", 5201, "class->vtable_size > finalize_slot");
      <D.26947>:
      class->has_finalize = 0;
      D.26924 = class->parent;
      if (D.26924 != 0B) goto <D.26948>; else goto <D.26949>;
      <D.26948>:
      D.26950 = BIT_FIELD_REF <*cmethod, 8, 168>;
      D.26951 = D.26950 & 16;
      if (D.26951 != 0) goto <D.26952>; else goto <D.26953>;
      <D.26952>:
      cmethod = MEM[(struct MonoMethodInflated *)cmethod].declaring;
      <D.26953>:
      default_finalize.263 = default_finalize;
      if (cmethod != default_finalize.263) goto <D.26955>; else goto <D.26956>;
      <D.26955>:
      class->has_finalize = 1;
      <D.26956>:
      <D.26949>:
      <D.26941>:
      <D.26923>:
    }
    <D.26921>:
    <D.26917>:
    <D.26915>:
    <D.26912>:
    mono_memory_barrier ();
    klass->has_finalize_inited = 1;
    mono_loader_unlock ();
  }
  <D.26908>:
  D.26958 = klass->has_finalize;
  D.26957 = (gboolean) D.26958;
  return D.26957;
  leave:
  mono_loader_unlock ();
  D.26957 = 0;
  return D.26957;
}


mono_is_corlib_image (struct MonoImage * image)
{
  unsigned char D.26960;
  unsigned char D.26961;
  gboolean D.26964;
  int iftmp.264;
  struct MonoAssembly * D.26968;
  int D.19945;
  int iftmp.265;
  int D.19944;
  const char[9] * D.26973;
  unsigned char D.26974;
  int D.26975;
  unsigned char D.26976;
  int D.26977;
  _Bool D.26978;
  _Bool D.26979;
  _Bool D.26980;
  const unsigned char * D.26983;
  unsigned char D.26984;
  int D.26985;
  const unsigned char * D.26986;
  unsigned char D.26987;
  int D.26988;
  _Bool D.26989;
  _Bool D.26990;
  const unsigned char * D.26993;
  unsigned char D.26994;
  int D.26995;
  const unsigned char * D.26996;
  unsigned char D.26997;
  int D.26998;
  _Bool D.26999;
  _Bool D.27000;
  const unsigned char * D.27003;
  unsigned char D.27004;
  int D.27005;
  const unsigned char * D.27006;
  unsigned char D.27007;
  int D.27008;
  const char * D.27010;
  struct MonoImage * D.27012;
  _Bool D.27013;

  D.26960 = BIT_FIELD_REF <*image, 8, 128>;
  D.26961 = D.26960 & 8;
  if (D.26961 != 0) goto <D.26962>; else goto <D.26963>;
  <D.26962>:
  D.26968 = image->assembly;
  if (D.26968 != 0B) goto <D.26969>; else goto <D.26966>;
  <D.26969>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      D.26968 = image->assembly;
      __s2 = D.26968->aname.name;
      D.26973 = "mscorlib";
      D.26974 = MEM[(const unsigned char *)D.26973];
      D.26975 = (int) D.26974;
      D.26976 = *__s2;
      D.26977 = (int) D.26976;
      __result = D.26975 - D.26977;
      {
        D.26978 = __s2_len != 0;
        D.26979 = __result == 0;
        D.26980 = D.26978 & D.26979;
        if (D.26980 != 0) goto <D.26981>; else goto <D.26982>;
        <D.26981>:
        D.26983 = &MEM[(void *)"mscorlib" + 1B];
        D.26984 = *D.26983;
        D.26985 = (int) D.26984;
        D.26986 = __s2 + 1;
        D.26987 = *D.26986;
        D.26988 = (int) D.26987;
        __result = D.26985 - D.26988;
        D.26989 = __s2_len > 1;
        D.26979 = __result == 0;
        D.26990 = D.26989 & D.26979;
        if (D.26990 != 0) goto <D.26991>; else goto <D.26992>;
        <D.26991>:
        D.26993 = &MEM[(void *)"mscorlib" + 2B];
        D.26994 = *D.26993;
        D.26995 = (int) D.26994;
        D.26996 = __s2 + 2;
        D.26997 = *D.26996;
        D.26998 = (int) D.26997;
        __result = D.26995 - D.26998;
        D.26999 = __s2_len > 2;
        D.26979 = __result == 0;
        D.27000 = D.26999 & D.26979;
        if (D.27000 != 0) goto <D.27001>; else goto <D.27002>;
        <D.27001>:
        D.27003 = &MEM[(void *)"mscorlib" + 3B];
        D.27004 = *D.27003;
        D.27005 = (int) D.27004;
        D.27006 = __s2 + 3;
        D.27007 = *D.27006;
        D.27008 = (int) D.27007;
        __result = D.27005 - D.27008;
        <D.27002>:
        <D.26992>:
        <D.26982>:
      }
      D.19944 = __result;
    }
    iftmp.265 = -D.19944;
    goto <D.27009>;
    <D.26972>:
    D.26968 = image->assembly;
    D.27010 = D.26968->aname.name;
    iftmp.265 = __builtin_strcmp (D.27010, "mscorlib");
    <D.27009>:
    D.19945 = iftmp.265;
  }
  if (D.19945 == 0) goto <D.27011>; else goto <D.26966>;
  <D.27011>:
  iftmp.264 = 1;
  goto <D.26967>;
  <D.26966>:
  iftmp.264 = 0;
  <D.26967>:
  D.26964 = iftmp.264;
  return D.26964;
  <D.26963>:
  D.27012 = mono_defaults.corlib;
  D.27013 = D.27012 == image;
  D.26964 = (gboolean) D.27013;
  return D.26964;
}


mono_class_setup_mono_type (struct MonoClass * class)
{
  struct MonoImage * D.27015;
  int D.19960;
  int iftmp.266;
  int D.19959;
  const char[7] * D.27021;
  unsigned char D.27022;
  int D.27023;
  unsigned char D.27024;
  int D.27025;
  _Bool D.27026;
  _Bool D.27027;
  _Bool D.27028;
  const unsigned char * D.27031;
  unsigned char D.27032;
  int D.27033;
  const unsigned char * D.27034;
  unsigned char D.27035;
  int D.27036;
  _Bool D.27037;
  _Bool D.27038;
  const unsigned char * D.27041;
  unsigned char D.27042;
  int D.27043;
  const unsigned char * D.27044;
  unsigned char D.27045;
  int D.27046;
  _Bool D.27047;
  _Bool D.27048;
  const unsigned char * D.27051;
  unsigned char D.27052;
  int D.27053;
  const unsigned char * D.27054;
  unsigned char D.27055;
  int D.27056;
  int D.19969;
  int iftmp.267;
  int D.19968;
  const char[10] * D.27063;
  unsigned char D.27064;
  int D.27065;
  unsigned char D.27066;
  int D.27067;
  _Bool D.27068;
  _Bool D.27069;
  _Bool D.27070;
  const unsigned char * D.27073;
  unsigned char D.27074;
  int D.27075;
  const unsigned char * D.27076;
  unsigned char D.27077;
  int D.27078;
  _Bool D.27079;
  _Bool D.27080;
  const unsigned char * D.27083;
  unsigned char D.27084;
  int D.27085;
  const unsigned char * D.27086;
  unsigned char D.27087;
  int D.27088;
  _Bool D.27089;
  _Bool D.27090;
  const unsigned char * D.27093;
  unsigned char D.27094;
  int D.27095;
  const unsigned char * D.27096;
  unsigned char D.27097;
  int D.27098;
  int D.19978;
  int iftmp.268;
  int D.19977;
  const char[5] * D.27106;
  unsigned char D.27107;
  int D.27108;
  unsigned char D.27109;
  int D.27110;
  _Bool D.27111;
  _Bool D.27112;
  _Bool D.27113;
  const unsigned char * D.27116;
  unsigned char D.27117;
  int D.27118;
  const unsigned char * D.27119;
  unsigned char D.27120;
  int D.27121;
  _Bool D.27122;
  _Bool D.27123;
  const unsigned char * D.27126;
  unsigned char D.27127;
  int D.27128;
  const unsigned char * D.27129;
  unsigned char D.27130;
  int D.27131;
  _Bool D.27132;
  _Bool D.27133;
  const unsigned char * D.27136;
  unsigned char D.27137;
  int D.27138;
  const unsigned char * D.27139;
  unsigned char D.27140;
  int D.27141;
  int D.19987;
  int iftmp.269;
  int D.19986;
  const char[7] * D.27149;
  unsigned char D.27150;
  int D.27151;
  unsigned char D.27152;
  int D.27153;
  _Bool D.27154;
  _Bool D.27155;
  _Bool D.27156;
  const unsigned char * D.27159;
  unsigned char D.27160;
  int D.27161;
  const unsigned char * D.27162;
  unsigned char D.27163;
  int D.27164;
  _Bool D.27165;
  _Bool D.27166;
  const unsigned char * D.27169;
  unsigned char D.27170;
  int D.27171;
  const unsigned char * D.27172;
  unsigned char D.27173;
  int D.27174;
  _Bool D.27175;
  _Bool D.27176;
  const unsigned char * D.27179;
  unsigned char D.27180;
  int D.27181;
  const unsigned char * D.27182;
  unsigned char D.27183;
  int D.27184;
  unsigned char D.27188;
  int D.19996;
  int iftmp.270;
  int D.19995;
  const char[7] * D.27193;
  unsigned char D.27194;
  int D.27195;
  unsigned char D.27196;
  int D.27197;
  _Bool D.27198;
  _Bool D.27199;
  _Bool D.27200;
  const unsigned char * D.27203;
  unsigned char D.27204;
  int D.27205;
  const unsigned char * D.27206;
  unsigned char D.27207;
  int D.27208;
  _Bool D.27209;
  _Bool D.27210;
  const unsigned char * D.27213;
  unsigned char D.27214;
  int D.27215;
  const unsigned char * D.27216;
  unsigned char D.27217;
  int D.27218;
  _Bool D.27219;
  _Bool D.27220;
  const unsigned char * D.27223;
  unsigned char D.27224;
  int D.27225;
  const unsigned char * D.27226;
  unsigned char D.27227;
  int D.27228;
  int D.20005;
  int iftmp.271;
  int D.20004;
  const char[15] * D.27236;
  unsigned char D.27237;
  int D.27238;
  unsigned char D.27239;
  int D.27240;
  _Bool D.27241;
  _Bool D.27242;
  _Bool D.27243;
  const unsigned char * D.27246;
  unsigned char D.27247;
  int D.27248;
  const unsigned char * D.27249;
  unsigned char D.27250;
  int D.27251;
  _Bool D.27252;
  _Bool D.27253;
  const unsigned char * D.27256;
  unsigned char D.27257;
  int D.27258;
  const unsigned char * D.27259;
  unsigned char D.27260;
  int D.27261;
  _Bool D.27262;
  _Bool D.27263;
  const unsigned char * D.27266;
  unsigned char D.27267;
  int D.27268;
  const unsigned char * D.27269;
  unsigned char D.27270;
  int D.27271;
  unsigned char D.27275;
  unsigned char D.27276;
  int D.20015;
  int iftmp.272;
  int D.20014;
  unsigned char D.27284;
  int D.27285;
  _Bool D.27286;
  _Bool D.27287;
  _Bool D.27288;
  const unsigned char * D.27291;
  unsigned char D.27292;
  int D.27293;
  _Bool D.27294;
  _Bool D.27295;
  const unsigned char * D.27298;
  unsigned char D.27299;
  int D.27300;
  _Bool D.27301;
  _Bool D.27302;
  const unsigned char * D.27305;
  unsigned char D.27306;
  int D.27307;
  char D.27311;
  int D.27312;
  int D.20025;
  int iftmp.273;
  int D.20024;
  const char[8] * D.27316;
  unsigned char D.27317;
  int D.27318;
  unsigned char D.27319;
  int D.27320;
  _Bool D.27321;
  _Bool D.27322;
  _Bool D.27323;
  const unsigned char * D.27326;
  unsigned char D.27327;
  int D.27328;
  const unsigned char * D.27329;
  unsigned char D.27330;
  int D.27331;
  _Bool D.27332;
  _Bool D.27333;
  const unsigned char * D.27336;
  unsigned char D.27337;
  int D.27338;
  const unsigned char * D.27339;
  unsigned char D.27340;
  int D.27341;
  _Bool D.27342;
  _Bool D.27343;
  const unsigned char * D.27346;
  unsigned char D.27347;
  int D.27348;
  const unsigned char * D.27349;
  unsigned char D.27350;
  int D.27351;
  int D.20034;
  int iftmp.274;
  int D.20033;
  const char[5] * D.27359;
  unsigned char D.27360;
  int D.27361;
  unsigned char D.27362;
  int D.27363;
  _Bool D.27364;
  _Bool D.27365;
  _Bool D.27366;
  const unsigned char * D.27369;
  unsigned char D.27370;
  int D.27371;
  const unsigned char * D.27372;
  unsigned char D.27373;
  int D.27374;
  _Bool D.27375;
  _Bool D.27376;
  const unsigned char * D.27379;
  unsigned char D.27380;
  int D.27381;
  const unsigned char * D.27382;
  unsigned char D.27383;
  int D.27384;
  _Bool D.27385;
  _Bool D.27386;
  const unsigned char * D.27389;
  unsigned char D.27390;
  int D.27391;
  const unsigned char * D.27392;
  unsigned char D.27393;
  int D.27394;
  int D.20045;
  int iftmp.275;
  int D.20044;
  const char[5] * D.27401;
  unsigned char D.27402;
  int D.27403;
  unsigned char D.27404;
  int D.27405;
  _Bool D.27406;
  _Bool D.27407;
  _Bool D.27408;
  const unsigned char * D.27411;
  unsigned char D.27412;
  int D.27413;
  const unsigned char * D.27414;
  unsigned char D.27415;
  int D.27416;
  _Bool D.27417;
  _Bool D.27418;
  const unsigned char * D.27421;
  unsigned char D.27422;
  int D.27423;
  const unsigned char * D.27424;
  unsigned char D.27425;
  int D.27426;
  _Bool D.27427;
  _Bool D.27428;
  const unsigned char * D.27431;
  unsigned char D.27432;
  int D.27433;
  const unsigned char * D.27434;
  unsigned char D.27435;
  int D.27436;
  int D.20055;
  int iftmp.276;
  int D.20054;
  const char[7] * D.27443;
  unsigned char D.27444;
  int D.27445;
  unsigned char D.27446;
  int D.27447;
  _Bool D.27448;
  _Bool D.27449;
  _Bool D.27450;
  const unsigned char * D.27453;
  unsigned char D.27454;
  int D.27455;
  const unsigned char * D.27456;
  unsigned char D.27457;
  int D.27458;
  _Bool D.27459;
  _Bool D.27460;
  const unsigned char * D.27463;
  unsigned char D.27464;
  int D.27465;
  const unsigned char * D.27466;
  unsigned char D.27467;
  int D.27468;
  _Bool D.27469;
  _Bool D.27470;
  const unsigned char * D.27473;
  unsigned char D.27474;
  int D.27475;
  const unsigned char * D.27476;
  unsigned char D.27477;
  int D.27478;
  int D.20065;
  int iftmp.277;
  int D.20064;
  const char[6] * D.27485;
  unsigned char D.27486;
  int D.27487;
  unsigned char D.27488;
  int D.27489;
  _Bool D.27490;
  _Bool D.27491;
  _Bool D.27492;
  const unsigned char * D.27495;
  unsigned char D.27496;
  int D.27497;
  const unsigned char * D.27498;
  unsigned char D.27499;
  int D.27500;
  _Bool D.27501;
  _Bool D.27502;
  const unsigned char * D.27505;
  unsigned char D.27506;
  int D.27507;
  const unsigned char * D.27508;
  unsigned char D.27509;
  int D.27510;
  _Bool D.27511;
  _Bool D.27512;
  const unsigned char * D.27515;
  unsigned char D.27516;
  int D.27517;
  const unsigned char * D.27518;
  unsigned char D.27519;
  int D.27520;
  int D.20074;
  int iftmp.278;
  int D.20073;
  const char[6] * D.27528;
  unsigned char D.27529;
  int D.27530;
  unsigned char D.27531;
  int D.27532;
  _Bool D.27533;
  _Bool D.27534;
  _Bool D.27535;
  const unsigned char * D.27538;
  unsigned char D.27539;
  int D.27540;
  const unsigned char * D.27541;
  unsigned char D.27542;
  int D.27543;
  _Bool D.27544;
  _Bool D.27545;
  const unsigned char * D.27548;
  unsigned char D.27549;
  int D.27550;
  const unsigned char * D.27551;
  unsigned char D.27552;
  int D.27553;
  _Bool D.27554;
  _Bool D.27555;
  const unsigned char * D.27558;
  unsigned char D.27559;
  int D.27560;
  const unsigned char * D.27561;
  unsigned char D.27562;
  int D.27563;
  int D.20083;
  int iftmp.279;
  int D.20082;
  const char[6] * D.27571;
  unsigned char D.27572;
  int D.27573;
  unsigned char D.27574;
  int D.27575;
  _Bool D.27576;
  _Bool D.27577;
  _Bool D.27578;
  const unsigned char * D.27581;
  unsigned char D.27582;
  int D.27583;
  const unsigned char * D.27584;
  unsigned char D.27585;
  int D.27586;
  _Bool D.27587;
  _Bool D.27588;
  const unsigned char * D.27591;
  unsigned char D.27592;
  int D.27593;
  const unsigned char * D.27594;
  unsigned char D.27595;
  int D.27596;
  _Bool D.27597;
  _Bool D.27598;
  const unsigned char * D.27601;
  unsigned char D.27602;
  int D.27603;
  const unsigned char * D.27604;
  unsigned char D.27605;
  int D.27606;
  int D.20092;
  int iftmp.280;
  int D.20091;
  const char[7] * D.27614;
  unsigned char D.27615;
  int D.27616;
  unsigned char D.27617;
  int D.27618;
  _Bool D.27619;
  _Bool D.27620;
  _Bool D.27621;
  const unsigned char * D.27624;
  unsigned char D.27625;
  int D.27626;
  const unsigned char * D.27627;
  unsigned char D.27628;
  int D.27629;
  _Bool D.27630;
  _Bool D.27631;
  const unsigned char * D.27634;
  unsigned char D.27635;
  int D.27636;
  const unsigned char * D.27637;
  unsigned char D.27638;
  int D.27639;
  _Bool D.27640;
  _Bool D.27641;
  const unsigned char * D.27644;
  unsigned char D.27645;
  int D.27646;
  const unsigned char * D.27647;
  unsigned char D.27648;
  int D.27649;
  int D.20102;
  int iftmp.281;
  int D.20101;
  const char[7] * D.27656;
  unsigned char D.27657;
  int D.27658;
  unsigned char D.27659;
  int D.27660;
  _Bool D.27661;
  _Bool D.27662;
  _Bool D.27663;
  const unsigned char * D.27666;
  unsigned char D.27667;
  int D.27668;
  const unsigned char * D.27669;
  unsigned char D.27670;
  int D.27671;
  _Bool D.27672;
  _Bool D.27673;
  const unsigned char * D.27676;
  unsigned char D.27677;
  int D.27678;
  const unsigned char * D.27679;
  unsigned char D.27680;
  int D.27681;
  _Bool D.27682;
  _Bool D.27683;
  const unsigned char * D.27686;
  unsigned char D.27687;
  int D.27688;
  const unsigned char * D.27689;
  unsigned char D.27690;
  int D.27691;
  int D.20111;
  int iftmp.282;
  int D.20110;
  const char[6] * D.27699;
  unsigned char D.27700;
  int D.27701;
  unsigned char D.27702;
  int D.27703;
  _Bool D.27704;
  _Bool D.27705;
  _Bool D.27706;
  const unsigned char * D.27709;
  unsigned char D.27710;
  int D.27711;
  const unsigned char * D.27712;
  unsigned char D.27713;
  int D.27714;
  _Bool D.27715;
  _Bool D.27716;
  const unsigned char * D.27719;
  unsigned char D.27720;
  int D.27721;
  const unsigned char * D.27722;
  unsigned char D.27723;
  int D.27724;
  _Bool D.27725;
  _Bool D.27726;
  const unsigned char * D.27729;
  unsigned char D.27730;
  int D.27731;
  const unsigned char * D.27732;
  unsigned char D.27733;
  int D.27734;
  int D.20121;
  int iftmp.283;
  int D.20120;
  const char[7] * D.27741;
  unsigned char D.27742;
  int D.27743;
  unsigned char D.27744;
  int D.27745;
  _Bool D.27746;
  _Bool D.27747;
  _Bool D.27748;
  const unsigned char * D.27751;
  unsigned char D.27752;
  int D.27753;
  const unsigned char * D.27754;
  unsigned char D.27755;
  int D.27756;
  _Bool D.27757;
  _Bool D.27758;
  const unsigned char * D.27761;
  unsigned char D.27762;
  int D.27763;
  const unsigned char * D.27764;
  unsigned char D.27765;
  int D.27766;
  _Bool D.27767;
  _Bool D.27768;
  const unsigned char * D.27771;
  unsigned char D.27772;
  int D.27773;
  const unsigned char * D.27774;
  unsigned char D.27775;
  int D.27776;
  int D.20130;
  int iftmp.284;
  int D.20129;
  const char[7] * D.27784;
  unsigned char D.27785;
  int D.27786;
  unsigned char D.27787;
  int D.27788;
  _Bool D.27789;
  _Bool D.27790;
  _Bool D.27791;
  const unsigned char * D.27794;
  unsigned char D.27795;
  int D.27796;
  const unsigned char * D.27797;
  unsigned char D.27798;
  int D.27799;
  _Bool D.27800;
  _Bool D.27801;
  const unsigned char * D.27804;
  unsigned char D.27805;
  int D.27806;
  const unsigned char * D.27807;
  unsigned char D.27808;
  int D.27809;
  _Bool D.27810;
  _Bool D.27811;
  const unsigned char * D.27814;
  unsigned char D.27815;
  int D.27816;
  const unsigned char * D.27817;
  unsigned char D.27818;
  int D.27819;
  int D.20139;
  int iftmp.285;
  int D.20138;
  const char[7] * D.27827;
  unsigned char D.27828;
  int D.27829;
  unsigned char D.27830;
  int D.27831;
  _Bool D.27832;
  _Bool D.27833;
  _Bool D.27834;
  const unsigned char * D.27837;
  unsigned char D.27838;
  int D.27839;
  const unsigned char * D.27840;
  unsigned char D.27841;
  int D.27842;
  _Bool D.27843;
  _Bool D.27844;
  const unsigned char * D.27847;
  unsigned char D.27848;
  int D.27849;
  const unsigned char * D.27850;
  unsigned char D.27851;
  int D.27852;
  _Bool D.27853;
  _Bool D.27854;
  const unsigned char * D.27857;
  unsigned char D.27858;
  int D.27859;
  const unsigned char * D.27860;
  unsigned char D.27861;
  int D.27862;
  int D.20148;
  int iftmp.286;
  int D.20147;
  const char[8] * D.27870;
  unsigned char D.27871;
  int D.27872;
  unsigned char D.27873;
  int D.27874;
  _Bool D.27875;
  _Bool D.27876;
  _Bool D.27877;
  const unsigned char * D.27880;
  unsigned char D.27881;
  int D.27882;
  const unsigned char * D.27883;
  unsigned char D.27884;
  int D.27885;
  _Bool D.27886;
  _Bool D.27887;
  const unsigned char * D.27890;
  unsigned char D.27891;
  int D.27892;
  const unsigned char * D.27893;
  unsigned char D.27894;
  int D.27895;
  _Bool D.27896;
  _Bool D.27897;
  const unsigned char * D.27900;
  unsigned char D.27901;
  int D.27902;
  const unsigned char * D.27903;
  unsigned char D.27904;
  int D.27905;
  int D.20158;
  int iftmp.287;
  int D.20157;
  unsigned char D.27912;
  int D.27913;
  _Bool D.27914;
  _Bool D.27915;
  _Bool D.27916;
  const unsigned char * D.27919;
  unsigned char D.27920;
  int D.27921;
  _Bool D.27922;
  _Bool D.27923;
  const unsigned char * D.27926;
  unsigned char D.27927;
  int D.27928;
  _Bool D.27929;
  _Bool D.27930;
  const unsigned char * D.27933;
  unsigned char D.27934;
  int D.27935;
  int D.20168;
  int iftmp.288;
  int D.20167;
  const char[5] * D.27942;
  unsigned char D.27943;
  int D.27944;
  unsigned char D.27945;
  int D.27946;
  _Bool D.27947;
  _Bool D.27948;
  _Bool D.27949;
  const unsigned char * D.27952;
  unsigned char D.27953;
  int D.27954;
  const unsigned char * D.27955;
  unsigned char D.27956;
  int D.27957;
  _Bool D.27958;
  _Bool D.27959;
  const unsigned char * D.27962;
  unsigned char D.27963;
  int D.27964;
  const unsigned char * D.27965;
  unsigned char D.27966;
  int D.27967;
  _Bool D.27968;
  _Bool D.27969;
  const unsigned char * D.27972;
  unsigned char D.27973;
  int D.27974;
  const unsigned char * D.27975;
  unsigned char D.27976;
  int D.27977;
  unsigned char D.27981;
  unsigned int D.27984;
  unsigned int D.27985;
  unsigned int D.27988;
  short unsigned int D.27989;
  const char * name;
  const char * nspace;
  gboolean is_corlib;

  name = class->name;
  nspace = class->name_space;
  D.27015 = class->image;
  is_corlib = mono_is_corlib_image (D.27015);
  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.27016>; else goto <D.27017>;
  <D.27016>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = nspace;
      D.27021 = "System";
      D.27022 = MEM[(const unsigned char *)D.27021];
      D.27023 = (int) D.27022;
      D.27024 = *__s2;
      D.27025 = (int) D.27024;
      __result = D.27023 - D.27025;
      {
        D.27026 = __s2_len != 0;
        D.27027 = __result == 0;
        D.27028 = D.27026 & D.27027;
        if (D.27028 != 0) goto <D.27029>; else goto <D.27030>;
        <D.27029>:
        D.27031 = &MEM[(void *)"System" + 1B];
        D.27032 = *D.27031;
        D.27033 = (int) D.27032;
        D.27034 = __s2 + 1;
        D.27035 = *D.27034;
        D.27036 = (int) D.27035;
        __result = D.27033 - D.27036;
        D.27037 = __s2_len > 1;
        D.27027 = __result == 0;
        D.27038 = D.27037 & D.27027;
        if (D.27038 != 0) goto <D.27039>; else goto <D.27040>;
        <D.27039>:
        D.27041 = &MEM[(void *)"System" + 2B];
        D.27042 = *D.27041;
        D.27043 = (int) D.27042;
        D.27044 = __s2 + 2;
        D.27045 = *D.27044;
        D.27046 = (int) D.27045;
        __result = D.27043 - D.27046;
        D.27047 = __s2_len > 2;
        D.27027 = __result == 0;
        D.27048 = D.27047 & D.27027;
        if (D.27048 != 0) goto <D.27049>; else goto <D.27050>;
        <D.27049>:
        D.27051 = &MEM[(void *)"System" + 3B];
        D.27052 = *D.27051;
        D.27053 = (int) D.27052;
        D.27054 = __s2 + 3;
        D.27055 = *D.27054;
        D.27056 = (int) D.27055;
        __result = D.27053 - D.27056;
        <D.27050>:
        <D.27040>:
        <D.27030>:
      }
      D.19959 = __result;
    }
    iftmp.266 = -D.19959;
    goto <D.27057>;
    <D.27020>:
    iftmp.266 = __builtin_strcmp (nspace, "System");
    <D.27057>:
    D.19960 = iftmp.266;
  }
  if (D.19960 == 0) goto <D.27058>; else goto <D.27059>;
  <D.27058>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = name;
      D.27063 = "ValueType";
      D.27064 = MEM[(const unsigned char *)D.27063];
      D.27065 = (int) D.27064;
      D.27066 = *__s2;
      D.27067 = (int) D.27066;
      __result = D.27065 - D.27067;
      {
        D.27068 = __s2_len != 0;
        D.27069 = __result == 0;
        D.27070 = D.27068 & D.27069;
        if (D.27070 != 0) goto <D.27071>; else goto <D.27072>;
        <D.27071>:
        D.27073 = &MEM[(void *)"ValueType" + 1B];
        D.27074 = *D.27073;
        D.27075 = (int) D.27074;
        D.27076 = __s2 + 1;
        D.27077 = *D.27076;
        D.27078 = (int) D.27077;
        __result = D.27075 - D.27078;
        D.27079 = __s2_len > 1;
        D.27069 = __result == 0;
        D.27080 = D.27079 & D.27069;
        if (D.27080 != 0) goto <D.27081>; else goto <D.27082>;
        <D.27081>:
        D.27083 = &MEM[(void *)"ValueType" + 2B];
        D.27084 = *D.27083;
        D.27085 = (int) D.27084;
        D.27086 = __s2 + 2;
        D.27087 = *D.27086;
        D.27088 = (int) D.27087;
        __result = D.27085 - D.27088;
        D.27089 = __s2_len > 2;
        D.27069 = __result == 0;
        D.27090 = D.27089 & D.27069;
        if (D.27090 != 0) goto <D.27091>; else goto <D.27092>;
        <D.27091>:
        D.27093 = &MEM[(void *)"ValueType" + 3B];
        D.27094 = *D.27093;
        D.27095 = (int) D.27094;
        D.27096 = __s2 + 3;
        D.27097 = *D.27096;
        D.27098 = (int) D.27097;
        __result = D.27095 - D.27098;
        <D.27092>:
        <D.27082>:
        <D.27072>:
      }
      D.19968 = __result;
    }
    iftmp.267 = -D.19968;
    goto <D.27099>;
    <D.27062>:
    iftmp.267 = __builtin_strcmp (name, "ValueType");
    <D.27099>:
    D.19969 = iftmp.267;
  }
  if (D.19969 == 0) goto <D.27100>; else goto <D.27101>;
  <D.27100>:
  class->blittable = 1;
  goto <D.27102>;
  <D.27101>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = name;
      D.27106 = "Enum";
      D.27107 = MEM[(const unsigned char *)D.27106];
      D.27108 = (int) D.27107;
      D.27109 = *__s2;
      D.27110 = (int) D.27109;
      __result = D.27108 - D.27110;
      {
        D.27111 = __s2_len != 0;
        D.27112 = __result == 0;
        D.27113 = D.27111 & D.27112;
        if (D.27113 != 0) goto <D.27114>; else goto <D.27115>;
        <D.27114>:
        D.27116 = &MEM[(void *)"Enum" + 1B];
        D.27117 = *D.27116;
        D.27118 = (int) D.27117;
        D.27119 = __s2 + 1;
        D.27120 = *D.27119;
        D.27121 = (int) D.27120;
        __result = D.27118 - D.27121;
        D.27122 = __s2_len > 1;
        D.27112 = __result == 0;
        D.27123 = D.27122 & D.27112;
        if (D.27123 != 0) goto <D.27124>; else goto <D.27125>;
        <D.27124>:
        D.27126 = &MEM[(void *)"Enum" + 2B];
        D.27127 = *D.27126;
        D.27128 = (int) D.27127;
        D.27129 = __s2 + 2;
        D.27130 = *D.27129;
        D.27131 = (int) D.27130;
        __result = D.27128 - D.27131;
        D.27132 = __s2_len > 2;
        D.27112 = __result == 0;
        D.27133 = D.27132 & D.27112;
        if (D.27133 != 0) goto <D.27134>; else goto <D.27135>;
        <D.27134>:
        D.27136 = &MEM[(void *)"Enum" + 3B];
        D.27137 = *D.27136;
        D.27138 = (int) D.27137;
        D.27139 = __s2 + 3;
        D.27140 = *D.27139;
        D.27141 = (int) D.27140;
        __result = D.27138 - D.27141;
        <D.27135>:
        <D.27125>:
        <D.27115>:
      }
      D.19977 = __result;
    }
    iftmp.268 = -D.19977;
    goto <D.27142>;
    <D.27105>:
    iftmp.268 = __builtin_strcmp (name, "Enum");
    <D.27142>:
    D.19978 = iftmp.268;
  }
  if (D.19978 == 0) goto <D.27143>; else goto <D.27144>;
  <D.27143>:
  class->valuetype = 0;
  class->enumtype = 0;
  goto <D.27145>;
  <D.27144>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = name;
      D.27149 = "Object";
      D.27150 = MEM[(const unsigned char *)D.27149];
      D.27151 = (int) D.27150;
      D.27152 = *__s2;
      D.27153 = (int) D.27152;
      __result = D.27151 - D.27153;
      {
        D.27154 = __s2_len != 0;
        D.27155 = __result == 0;
        D.27156 = D.27154 & D.27155;
        if (D.27156 != 0) goto <D.27157>; else goto <D.27158>;
        <D.27157>:
        D.27159 = &MEM[(void *)"Object" + 1B];
        D.27160 = *D.27159;
        D.27161 = (int) D.27160;
        D.27162 = __s2 + 1;
        D.27163 = *D.27162;
        D.27164 = (int) D.27163;
        __result = D.27161 - D.27164;
        D.27165 = __s2_len > 1;
        D.27155 = __result == 0;
        D.27166 = D.27165 & D.27155;
        if (D.27166 != 0) goto <D.27167>; else goto <D.27168>;
        <D.27167>:
        D.27169 = &MEM[(void *)"Object" + 2B];
        D.27170 = *D.27169;
        D.27171 = (int) D.27170;
        D.27172 = __s2 + 2;
        D.27173 = *D.27172;
        D.27174 = (int) D.27173;
        __result = D.27171 - D.27174;
        D.27175 = __s2_len > 2;
        D.27155 = __result == 0;
        D.27176 = D.27175 & D.27155;
        if (D.27176 != 0) goto <D.27177>; else goto <D.27178>;
        <D.27177>:
        D.27179 = &MEM[(void *)"Object" + 3B];
        D.27180 = *D.27179;
        D.27181 = (int) D.27180;
        D.27182 = __s2 + 3;
        D.27183 = *D.27182;
        D.27184 = (int) D.27183;
        __result = D.27181 - D.27184;
        <D.27178>:
        <D.27168>:
        <D.27158>:
      }
      D.19986 = __result;
    }
    iftmp.269 = -D.19986;
    goto <D.27185>;
    <D.27148>:
    iftmp.269 = __builtin_strcmp (name, "Object");
    <D.27185>:
    D.19987 = iftmp.269;
  }
  if (D.19987 == 0) goto <D.27186>; else goto <D.27187>;
  <D.27186>:
  class->byval_arg.type = 28;
  D.27188 = class->byval_arg.type;
  class->this_arg.type = D.27188;
  goto <D.27189>;
  <D.27187>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = name;
      D.27193 = "String";
      D.27194 = MEM[(const unsigned char *)D.27193];
      D.27195 = (int) D.27194;
      D.27196 = *__s2;
      D.27197 = (int) D.27196;
      __result = D.27195 - D.27197;
      {
        D.27198 = __s2_len != 0;
        D.27199 = __result == 0;
        D.27200 = D.27198 & D.27199;
        if (D.27200 != 0) goto <D.27201>; else goto <D.27202>;
        <D.27201>:
        D.27203 = &MEM[(void *)"String" + 1B];
        D.27204 = *D.27203;
        D.27205 = (int) D.27204;
        D.27206 = __s2 + 1;
        D.27207 = *D.27206;
        D.27208 = (int) D.27207;
        __result = D.27205 - D.27208;
        D.27209 = __s2_len > 1;
        D.27199 = __result == 0;
        D.27210 = D.27209 & D.27199;
        if (D.27210 != 0) goto <D.27211>; else goto <D.27212>;
        <D.27211>:
        D.27213 = &MEM[(void *)"String" + 2B];
        D.27214 = *D.27213;
        D.27215 = (int) D.27214;
        D.27216 = __s2 + 2;
        D.27217 = *D.27216;
        D.27218 = (int) D.27217;
        __result = D.27215 - D.27218;
        D.27219 = __s2_len > 2;
        D.27199 = __result == 0;
        D.27220 = D.27219 & D.27199;
        if (D.27220 != 0) goto <D.27221>; else goto <D.27222>;
        <D.27221>:
        D.27223 = &MEM[(void *)"String" + 3B];
        D.27224 = *D.27223;
        D.27225 = (int) D.27224;
        D.27226 = __s2 + 3;
        D.27227 = *D.27226;
        D.27228 = (int) D.27227;
        __result = D.27225 - D.27228;
        <D.27222>:
        <D.27212>:
        <D.27202>:
      }
      D.19995 = __result;
    }
    iftmp.270 = -D.19995;
    goto <D.27229>;
    <D.27192>:
    iftmp.270 = __builtin_strcmp (name, "String");
    <D.27229>:
    D.19996 = iftmp.270;
  }
  if (D.19996 == 0) goto <D.27230>; else goto <D.27231>;
  <D.27230>:
  class->byval_arg.type = 14;
  D.27188 = class->byval_arg.type;
  class->this_arg.type = D.27188;
  goto <D.27232>;
  <D.27231>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = name;
      D.27236 = "TypedReference";
      D.27237 = MEM[(const unsigned char *)D.27236];
      D.27238 = (int) D.27237;
      D.27239 = *__s2;
      D.27240 = (int) D.27239;
      __result = D.27238 - D.27240;
      {
        D.27241 = __s2_len != 0;
        D.27242 = __result == 0;
        D.27243 = D.27241 & D.27242;
        if (D.27243 != 0) goto <D.27244>; else goto <D.27245>;
        <D.27244>:
        D.27246 = &MEM[(void *)"TypedReference" + 1B];
        D.27247 = *D.27246;
        D.27248 = (int) D.27247;
        D.27249 = __s2 + 1;
        D.27250 = *D.27249;
        D.27251 = (int) D.27250;
        __result = D.27248 - D.27251;
        D.27252 = __s2_len > 1;
        D.27242 = __result == 0;
        D.27253 = D.27252 & D.27242;
        if (D.27253 != 0) goto <D.27254>; else goto <D.27255>;
        <D.27254>:
        D.27256 = &MEM[(void *)"TypedReference" + 2B];
        D.27257 = *D.27256;
        D.27258 = (int) D.27257;
        D.27259 = __s2 + 2;
        D.27260 = *D.27259;
        D.27261 = (int) D.27260;
        __result = D.27258 - D.27261;
        D.27262 = __s2_len > 2;
        D.27242 = __result == 0;
        D.27263 = D.27262 & D.27242;
        if (D.27263 != 0) goto <D.27264>; else goto <D.27265>;
        <D.27264>:
        D.27266 = &MEM[(void *)"TypedReference" + 3B];
        D.27267 = *D.27266;
        D.27268 = (int) D.27267;
        D.27269 = __s2 + 3;
        D.27270 = *D.27269;
        D.27271 = (int) D.27270;
        __result = D.27268 - D.27271;
        <D.27265>:
        <D.27255>:
        <D.27245>:
      }
      D.20004 = __result;
    }
    iftmp.271 = -D.20004;
    goto <D.27272>;
    <D.27235>:
    iftmp.271 = __builtin_strcmp (name, "TypedReference");
    <D.27272>:
    D.20005 = iftmp.271;
  }
  if (D.20005 == 0) goto <D.27273>; else goto <D.27274>;
  <D.27273>:
  class->byval_arg.type = 22;
  D.27188 = class->byval_arg.type;
  class->this_arg.type = D.27188;
  <D.27274>:
  <D.27232>:
  <D.27189>:
  <D.27145>:
  <D.27102>:
  <D.27059>:
  <D.27017>:
  D.27275 = BIT_FIELD_REF <*class, 8, 160>;
  D.27276 = D.27275 & 8;
  if (D.27276 != 0) goto <D.27277>; else goto <D.27278>;
  <D.27277>:
  {
    int t;

    t = 17;
    if (is_corlib != 0) goto <D.27279>; else goto <D.27280>;
    <D.27279>:
    {
      size_t __s1_len;
      size_t __s2_len;

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

        __s2 = nspace;
        D.27021 = "System";
        D.27022 = MEM[(const unsigned char *)D.27021];
        D.27023 = (int) D.27022;
        D.27284 = *__s2;
        D.27285 = (int) D.27284;
        __result = D.27023 - D.27285;
        {
          D.27286 = __s2_len != 0;
          D.27287 = __result == 0;
          D.27288 = D.27286 & D.27287;
          if (D.27288 != 0) goto <D.27289>; else goto <D.27290>;
          <D.27289>:
          D.27031 = &MEM[(void *)"System" + 1B];
          D.27032 = *D.27031;
          D.27033 = (int) D.27032;
          D.27291 = __s2 + 1;
          D.27292 = *D.27291;
          D.27293 = (int) D.27292;
          __result = D.27033 - D.27293;
          D.27294 = __s2_len > 1;
          D.27287 = __result == 0;
          D.27295 = D.27294 & D.27287;
          if (D.27295 != 0) goto <D.27296>; else goto <D.27297>;
          <D.27296>:
          D.27041 = &MEM[(void *)"System" + 2B];
          D.27042 = *D.27041;
          D.27043 = (int) D.27042;
          D.27298 = __s2 + 2;
          D.27299 = *D.27298;
          D.27300 = (int) D.27299;
          __result = D.27043 - D.27300;
          D.27301 = __s2_len > 2;
          D.27287 = __result == 0;
          D.27302 = D.27301 & D.27287;
          if (D.27302 != 0) goto <D.27303>; else goto <D.27304>;
          <D.27303>:
          D.27051 = &MEM[(void *)"System" + 3B];
          D.27052 = *D.27051;
          D.27053 = (int) D.27052;
          D.27305 = __s2 + 3;
          D.27306 = *D.27305;
          D.27307 = (int) D.27306;
          __result = D.27053 - D.27307;
          <D.27304>:
          <D.27297>:
          <D.27290>:
        }
        D.20014 = __result;
      }
      iftmp.272 = -D.20014;
      goto <D.27308>;
      <D.27283>:
      iftmp.272 = __builtin_strcmp (nspace, "System");
      <D.27308>:
      D.20015 = iftmp.272;
    }
    if (D.20015 == 0) goto <D.27309>; else goto <D.27310>;
    <D.27309>:
    D.27311 = *name;
    D.27312 = (int) D.27311;
    switch (D.27312) <default: <D.20169>, case 66: <D.20016>, case 67: <D.20036>, case 68: <D.20046>, case 73: <D.20056>, case 83: <D.20093>, case 84: <D.20149>, case 85: <D.20112>, case 86: <D.20159>>
    <D.20016>:
    {
      size_t __s1_len;
      size_t __s2_len;

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

        __s2 = name;
        D.27316 = "Boolean";
        D.27317 = MEM[(const unsigned char *)D.27316];
        D.27318 = (int) D.27317;
        D.27319 = *__s2;
        D.27320 = (int) D.27319;
        __result = D.27318 - D.27320;
        {
          D.27321 = __s2_len != 0;
          D.27322 = __result == 0;
          D.27323 = D.27321 & D.27322;
          if (D.27323 != 0) goto <D.27324>; else goto <D.27325>;
          <D.27324>:
          D.27326 = &MEM[(void *)"Boolean" + 1B];
          D.27327 = *D.27326;
          D.27328 = (int) D.27327;
          D.27329 = __s2 + 1;
          D.27330 = *D.27329;
          D.27331 = (int) D.27330;
          __result = D.27328 - D.27331;
          D.27332 = __s2_len > 1;
          D.27322 = __result == 0;
          D.27333 = D.27332 & D.27322;
          if (D.27333 != 0) goto <D.27334>; else goto <D.27335>;
          <D.27334>:
          D.27336 = &MEM[(void *)"Boolean" + 2B];
          D.27337 = *D.27336;
          D.27338 = (int) D.27337;
          D.27339 = __s2 + 2;
          D.27340 = *D.27339;
          D.27341 = (int) D.27340;
          __result = D.27338 - D.27341;
          D.27342 = __s2_len > 2;
          D.27322 = __result == 0;
          D.27343 = D.27342 & D.27322;
          if (D.27343 != 0) goto <D.27344>; else goto <D.27345>;
          <D.27344>:
          D.27346 = &MEM[(void *)"Boolean" + 3B];
          D.27347 = *D.27346;
          D.27348 = (int) D.27347;
          D.27349 = __s2 + 3;
          D.27350 = *D.27349;
          D.27351 = (int) D.27350;
          __result = D.27348 - D.27351;
          <D.27345>:
          <D.27335>:
          <D.27325>:
        }
        D.20024 = __result;
      }
      iftmp.273 = -D.20024;
      goto <D.27352>;
      <D.27315>:
      iftmp.273 = __builtin_strcmp (name, "Boolean");
      <D.27352>:
      D.20025 = iftmp.273;
    }
    if (D.20025 == 0) goto <D.27353>; else goto <D.27354>;
    <D.27353>:
    t = 2;
    goto <D.27355>;
    <D.27354>:
    {
      size_t __s1_len;
      size_t __s2_len;

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

        __s2 = name;
        D.27359 = "Byte";
        D.27360 = MEM[(const unsigned char *)D.27359];
        D.27361 = (int) D.27360;
        D.27362 = *__s2;
        D.27363 = (int) D.27362;
        __result = D.27361 - D.27363;
        {
          D.27364 = __s2_len != 0;
          D.27365 = __result == 0;
          D.27366 = D.27364 & D.27365;
          if (D.27366 != 0) goto <D.27367>; else goto <D.27368>;
          <D.27367>:
          D.27369 = &MEM[(void *)"Byte" + 1B];
          D.27370 = *D.27369;
          D.27371 = (int) D.27370;
          D.27372 = __s2 + 1;
          D.27373 = *D.27372;
          D.27374 = (int) D.27373;
          __result = D.27371 - D.27374;
          D.27375 = __s2_len > 1;
          D.27365 = __result == 0;
          D.27376 = D.27375 & D.27365;
          if (D.27376 != 0) goto <D.27377>; else goto <D.27378>;
          <D.27377>:
          D.27379 = &MEM[(void *)"Byte" + 2B];
          D.27380 = *D.27379;
          D.27381 = (int) D.27380;
          D.27382 = __s2 + 2;
          D.27383 = *D.27382;
          D.27384 = (int) D.27383;
          __result = D.27381 - D.27384;
          D.27385 = __s2_len > 2;
          D.27365 = __result == 0;
          D.27386 = D.27385 & D.27365;
          if (D.27386 != 0) goto <D.27387>; else goto <D.27388>;
          <D.27387>:
          D.27389 = &MEM[(void *)"Byte" + 3B];
          D.27390 = *D.27389;
          D.27391 = (int) D.27390;
          D.27392 = __s2 + 3;
          D.27393 = *D.27392;
          D.27394 = (int) D.27393;
          __result = D.27391 - D.27394;
          <D.27388>:
          <D.27378>:
          <D.27368>:
        }
        D.20033 = __result;
      }
      iftmp.274 = -D.20033;
      goto <D.27395>;
      <D.27358>:
      iftmp.274 = __builtin_strcmp (name, "Byte");
      <D.27395>:
      D.20034 = iftmp.274;
    }
    if (D.20034 == 0) goto <D.27396>; else goto <D.27397>;
    <D.27396>:
    t = 5;
    class->blittable = 1;
    <D.27397>:
    <D.27355>:
    goto <D.20035>;
    <D.20036>:
    {
      size_t __s1_len;
      size_t __s2_len;

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

        __s2 = name;
        D.27401 = "Char";
        D.27402 = MEM[(const unsigned char *)D.27401];
        D.27403 = (int) D.27402;
        D.27404 = *__s2;
        D.27405 = (int) D.27404;
        __result = D.27403 - D.27405;
        {
          D.27406 = __s2_len != 0;
          D.27407 = __result == 0;
          D.27408 = D.27406 & D.27407;
          if (D.27408 != 0) goto <D.27409>; else goto <D.27410>;
          <D.27409>:
          D.27411 = &MEM[(void *)"Char" + 1B];
          D.27412 = *D.27411;
          D.27413 = (int) D.27412;
          D.27414 = __s2 + 1;
          D.27415 = *D.27414;
          D.27416 = (int) D.27415;
          __result = D.27413 - D.27416;
          D.27417 = __s2_len > 1;
          D.27407 = __result == 0;
          D.27418 = D.27417 & D.27407;
          if (D.27418 != 0) goto <D.27419>; else goto <D.27420>;
          <D.27419>:
          D.27421 = &MEM[(void *)"Char" + 2B];
          D.27422 = *D.27421;
          D.27423 = (int) D.27422;
          D.27424 = __s2 + 2;
          D.27425 = *D.27424;
          D.27426 = (int) D.27425;
          __result = D.27423 - D.27426;
          D.27427 = __s2_len > 2;
          D.27407 = __result == 0;
          D.27428 = D.27427 & D.27407;
          if (D.27428 != 0) goto <D.27429>; else goto <D.27430>;
          <D.27429>:
          D.27431 = &MEM[(void *)"Char" + 3B];
          D.27432 = *D.27431;
          D.27433 = (int) D.27432;
          D.27434 = __s2 + 3;
          D.27435 = *D.27434;
          D.27436 = (int) D.27435;
          __result = D.27433 - D.27436;
          <D.27430>:
          <D.27420>:
          <D.27410>:
        }
        D.20044 = __result;
      }
      iftmp.275 = -D.20044;
      goto <D.27437>;
      <D.27400>:
      iftmp.275 = __builtin_strcmp (name, "Char");
      <D.27437>:
      D.20045 = iftmp.275;
    }
    if (D.20045 == 0) goto <D.27438>; else goto <D.27439>;
    <D.27438>:
    t = 3;
    <D.27439>:
    goto <D.20035>;
    <D.20046>:
    {
      size_t __s1_len;
      size_t __s2_len;

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

        __s2 = name;
        D.27443 = "Double";
        D.27444 = MEM[(const unsigned char *)D.27443];
        D.27445 = (int) D.27444;
        D.27446 = *__s2;
        D.27447 = (int) D.27446;
        __result = D.27445 - D.27447;
        {
          D.27448 = __s2_len != 0;
          D.27449 = __result == 0;
          D.27450 = D.27448 & D.27449;
          if (D.27450 != 0) goto <D.27451>; else goto <D.27452>;
          <D.27451>:
          D.27453 = &MEM[(void *)"Double" + 1B];
          D.27454 = *D.27453;
          D.27455 = (int) D.27454;
          D.27456 = __s2 + 1;
          D.27457 = *D.27456;
          D.27458 = (int) D.27457;
          __result = D.27455 - D.27458;
          D.27459 = __s2_len > 1;
          D.27449 = __result == 0;
          D.27460 = D.27459 & D.27449;
          if (D.27460 != 0) goto <D.27461>; else goto <D.27462>;
          <D.27461>:
          D.27463 = &MEM[(void *)"Double" + 2B];
          D.27464 = *D.27463;
          D.27465 = (int) D.27464;
          D.27466 = __s2 + 2;
          D.27467 = *D.27466;
          D.27468 = (int) D.27467;
          __result = D.27465 - D.27468;
          D.27469 = __s2_len > 2;
          D.27449 = __result == 0;
          D.27470 = D.27469 & D.27449;
          if (D.27470 != 0) goto <D.27471>; else goto <D.27472>;
          <D.27471>:
          D.27473 = &MEM[(void *)"Double" + 3B];
          D.27474 = *D.27473;
          D.27475 = (int) D.27474;
          D.27476 = __s2 + 3;
          D.27477 = *D.27476;
          D.27478 = (int) D.27477;
          __result = D.27475 - D.27478;
          <D.27472>:
          <D.27462>:
          <D.27452>:
        }
        D.20054 = __result;
      }
      iftmp.276 = -D.20054;
      goto <D.27479>;
      <D.27442>:
      iftmp.276 = __builtin_strcmp (name, "Double");
      <D.27479>:
      D.20055 = iftmp.276;
    }
    if (D.20055 == 0) goto <D.27480>; else goto <D.27481>;
    <D.27480>:
    t = 13;
    class->blittable = 1;
    <D.27481>:
    goto <D.20035>;
    <D.20056>:
    {
      size_t __s1_len;
      size_t __s2_len;

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

        __s2 = name;
        D.27485 = "Int32";
        D.27486 = MEM[(const unsigned char *)D.27485];
        D.27487 = (int) D.27486;
        D.27488 = *__s2;
        D.27489 = (int) D.27488;
        __result = D.27487 - D.27489;
        {
          D.27490 = __s2_len != 0;
          D.27491 = __result == 0;
          D.27492 = D.27490 & D.27491;
          if (D.27492 != 0) goto <D.27493>; else goto <D.27494>;
          <D.27493>:
          D.27495 = &MEM[(void *)"Int32" + 1B];
          D.27496 = *D.27495;
          D.27497 = (int) D.27496;
          D.27498 = __s2 + 1;
          D.27499 = *D.27498;
          D.27500 = (int) D.27499;
          __result = D.27497 - D.27500;
          D.27501 = __s2_len > 1;
          D.27491 = __result == 0;
          D.27502 = D.27501 & D.27491;
          if (D.27502 != 0) goto <D.27503>; else goto <D.27504>;
          <D.27503>:
          D.27505 = &MEM[(void *)"Int32" + 2B];
          D.27506 = *D.27505;
          D.27507 = (int) D.27506;
          D.27508 = __s2 + 2;
          D.27509 = *D.27508;
          D.27510 = (int) D.27509;
          __result = D.27507 - D.27510;
          D.27511 = __s2_len > 2;
          D.27491 = __result == 0;
          D.27512 = D.27511 & D.27491;
          if (D.27512 != 0) goto <D.27513>; else goto <D.27514>;
          <D.27513>:
          D.27515 = &MEM[(void *)"Int32" + 3B];
          D.27516 = *D.27515;
          D.27517 = (int) D.27516;
          D.27518 = __s2 + 3;
          D.27519 = *D.27518;
          D.27520 = (int) D.27519;
          __result = D.27517 - D.27520;
          <D.27514>:
          <D.27504>:
          <D.27494>:
        }
        D.20064 = __result;
      }
      iftmp.277 = -D.20064;
      goto <D.27521>;
      <D.27484>:
      iftmp.277 = __builtin_strcmp (name, "Int32");
      <D.27521>:
      D.20065 = iftmp.277;
    }
    if (D.20065 == 0) goto <D.27522>; else goto <D.27523>;
    <D.27522>:
    t = 8;
    class->blittable = 1;
    goto <D.27524>;
    <D.27523>:
    {
      size_t __s1_len;
      size_t __s2_len;

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

        __s2 = name;
        D.27528 = "Int16";
        D.27529 = MEM[(const unsigned char *)D.27528];
        D.27530 = (int) D.27529;
        D.27531 = *__s2;
        D.27532 = (int) D.27531;
        __result = D.27530 - D.27532;
        {
          D.27533 = __s2_len != 0;
          D.27534 = __result == 0;
          D.27535 = D.27533 & D.27534;
          if (D.27535 != 0) goto <D.27536>; else goto <D.27537>;
          <D.27536>:
          D.27538 = &MEM[(void *)"Int16" + 1B];
          D.27539 = *D.27538;
          D.27540 = (int) D.27539;
          D.27541 = __s2 + 1;
          D.27542 = *D.27541;
          D.27543 = (int) D.27542;
          __result = D.27540 - D.27543;
          D.27544 = __s2_len > 1;
          D.27534 = __result == 0;
          D.27545 = D.27544 & D.27534;
          if (D.27545 != 0) goto <D.27546>; else goto <D.27547>;
          <D.27546>:
          D.27548 = &MEM[(void *)"Int16" + 2B];
          D.27549 = *D.27548;
          D.27550 = (int) D.27549;
          D.27551 = __s2 + 2;
          D.27552 = *D.27551;
          D.27553 = (int) D.27552;
          __result = D.27550 - D.27553;
          D.27554 = __s2_len > 2;
          D.27534 = __result == 0;
          D.27555 = D.27554 & D.27534;
          if (D.27555 != 0) goto <D.27556>; else goto <D.27557>;
          <D.27556>:
          D.27558 = &MEM[(void *)"Int16" + 3B];
          D.27559 = *D.27558;
          D.27560 = (int) D.27559;
          D.27561 = __s2 + 3;
          D.27562 = *D.27561;
          D.27563 = (int) D.27562;
          __result = D.27560 - D.27563;
          <D.27557>:
          <D.27547>:
          <D.27537>:
        }
        D.20073 = __result;
      }
      iftmp.278 = -D.20073;
      goto <D.27564>;
      <D.27527>:
      iftmp.278 = __builtin_strcmp (name, "Int16");
      <D.27564>:
      D.20074 = iftmp.278;
    }
    if (D.20074 == 0) goto <D.27565>; else goto <D.27566>;
    <D.27565>:
    t = 6;
    class->blittable = 1;
    goto <D.27567>;
    <D.27566>:
    {
      size_t __s1_len;
      size_t __s2_len;

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

        __s2 = name;
        D.27571 = "Int64";
        D.27572 = MEM[(const unsigned char *)D.27571];
        D.27573 = (int) D.27572;
        D.27574 = *__s2;
        D.27575 = (int) D.27574;
        __result = D.27573 - D.27575;
        {
          D.27576 = __s2_len != 0;
          D.27577 = __result == 0;
          D.27578 = D.27576 & D.27577;
          if (D.27578 != 0) goto <D.27579>; else goto <D.27580>;
          <D.27579>:
          D.27581 = &MEM[(void *)"Int64" + 1B];
          D.27582 = *D.27581;
          D.27583 = (int) D.27582;
          D.27584 = __s2 + 1;
          D.27585 = *D.27584;
          D.27586 = (int) D.27585;
          __result = D.27583 - D.27586;
          D.27587 = __s2_len > 1;
          D.27577 = __result == 0;
          D.27588 = D.27587 & D.27577;
          if (D.27588 != 0) goto <D.27589>; else goto <D.27590>;
          <D.27589>:
          D.27591 = &MEM[(void *)"Int64" + 2B];
          D.27592 = *D.27591;
          D.27593 = (int) D.27592;
          D.27594 = __s2 + 2;
          D.27595 = *D.27594;
          D.27596 = (int) D.27595;
          __result = D.27593 - D.27596;
          D.27597 = __s2_len > 2;
          D.27577 = __result == 0;
          D.27598 = D.27597 & D.27577;
          if (D.27598 != 0) goto <D.27599>; else goto <D.27600>;
          <D.27599>:
          D.27601 = &MEM[(void *)"Int64" + 3B];
          D.27602 = *D.27601;
          D.27603 = (int) D.27602;
          D.27604 = __s2 + 3;
          D.27605 = *D.27604;
          D.27606 = (int) D.27605;
          __result = D.27603 - D.27606;
          <D.27600>:
          <D.27590>:
          <D.27580>:
        }
        D.20082 = __result;
      }
      iftmp.279 = -D.20082;
      goto <D.27607>;
      <D.27570>:
      iftmp.279 = __builtin_strcmp (name, "Int64");
      <D.27607>:
      D.20083 = iftmp.279;
    }
    if (D.20083 == 0) goto <D.27608>; else goto <D.27609>;
    <D.27608>:
    t = 10;
    class->blittable = 1;
    goto <D.27610>;
    <D.27609>:
    {
      size_t __s1_len;
      size_t __s2_len;

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

        __s2 = name;
        D.27614 = "IntPtr";
        D.27615 = MEM[(const unsigned char *)D.27614];
        D.27616 = (int) D.27615;
        D.27617 = *__s2;
        D.27618 = (int) D.27617;
        __result = D.27616 - D.27618;
        {
          D.27619 = __s2_len != 0;
          D.27620 = __result == 0;
          D.27621 = D.27619 & D.27620;
          if (D.27621 != 0) goto <D.27622>; else goto <D.27623>;
          <D.27622>:
          D.27624 = &MEM[(void *)"IntPtr" + 1B];
          D.27625 = *D.27624;
          D.27626 = (int) D.27625;
          D.27627 = __s2 + 1;
          D.27628 = *D.27627;
          D.27629 = (int) D.27628;
          __result = D.27626 - D.27629;
          D.27630 = __s2_len > 1;
          D.27620 = __result == 0;
          D.27631 = D.27630 & D.27620;
          if (D.27631 != 0) goto <D.27632>; else goto <D.27633>;
          <D.27632>:
          D.27634 = &MEM[(void *)"IntPtr" + 2B];
          D.27635 = *D.27634;
          D.27636 = (int) D.27635;
          D.27637 = __s2 + 2;
          D.27638 = *D.27637;
          D.27639 = (int) D.27638;
          __result = D.27636 - D.27639;
          D.27640 = __s2_len > 2;
          D.27620 = __result == 0;
          D.27641 = D.27640 & D.27620;
          if (D.27641 != 0) goto <D.27642>; else goto <D.27643>;
          <D.27642>:
          D.27644 = &MEM[(void *)"IntPtr" + 3B];
          D.27645 = *D.27644;
          D.27646 = (int) D.27645;
          D.27647 = __s2 + 3;
          D.27648 = *D.27647;
          D.27649 = (int) D.27648;
          __result = D.27646 - D.27649;
          <D.27643>:
          <D.27633>:
          <D.27623>:
        }
        D.20091 = __result;
      }
      iftmp.280 = -D.20091;
      goto <D.27650>;
      <D.27613>:
      iftmp.280 = __builtin_strcmp (name, "IntPtr");
      <D.27650>:
      D.20092 = iftmp.280;
    }
    if (D.20092 == 0) goto <D.27651>; else goto <D.27652>;
    <D.27651>:
    t = 24;
    class->blittable = 1;
    <D.27652>:
    <D.27610>:
    <D.27567>:
    <D.27524>:
    goto <D.20035>;
    <D.20093>:
    {
      size_t __s1_len;
      size_t __s2_len;

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

        __s2 = name;
        D.27656 = "Single";
        D.27657 = MEM[(const unsigned char *)D.27656];
        D.27658 = (int) D.27657;
        D.27659 = *__s2;
        D.27660 = (int) D.27659;
        __result = D.27658 - D.27660;
        {
          D.27661 = __s2_len != 0;
          D.27662 = __result == 0;
          D.27663 = D.27661 & D.27662;
          if (D.27663 != 0) goto <D.27664>; else goto <D.27665>;
          <D.27664>:
          D.27666 = &MEM[(void *)"Single" + 1B];
          D.27667 = *D.27666;
          D.27668 = (int) D.27667;
          D.27669 = __s2 + 1;
          D.27670 = *D.27669;
          D.27671 = (int) D.27670;
          __result = D.27668 - D.27671;
          D.27672 = __s2_len > 1;
          D.27662 = __result == 0;
          D.27673 = D.27672 & D.27662;
          if (D.27673 != 0) goto <D.27674>; else goto <D.27675>;
          <D.27674>:
          D.27676 = &MEM[(void *)"Single" + 2B];
          D.27677 = *D.27676;
          D.27678 = (int) D.27677;
          D.27679 = __s2 + 2;
          D.27680 = *D.27679;
          D.27681 = (int) D.27680;
          __result = D.27678 - D.27681;
          D.27682 = __s2_len > 2;
          D.27662 = __result == 0;
          D.27683 = D.27682 & D.27662;
          if (D.27683 != 0) goto <D.27684>; else goto <D.27685>;
          <D.27684>:
          D.27686 = &MEM[(void *)"Single" + 3B];
          D.27687 = *D.27686;
          D.27688 = (int) D.27687;
          D.27689 = __s2 + 3;
          D.27690 = *D.27689;
          D.27691 = (int) D.27690;
          __result = D.27688 - D.27691;
          <D.27685>:
          <D.27675>:
          <D.27665>:
        }
        D.20101 = __result;
      }
      iftmp.281 = -D.20101;
      goto <D.27692>;
      <D.27655>:
      iftmp.281 = __builtin_strcmp (name, "Single");
      <D.27692>:
      D.20102 = iftmp.281;
    }
    if (D.20102 == 0) goto <D.27693>; else goto <D.27694>;
    <D.27693>:
    t = 12;
    class->blittable = 1;
    goto <D.27695>;
    <D.27694>:
    {
      size_t __s1_len;
      size_t __s2_len;

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

        __s2 = name;
        D.27699 = "SByte";
        D.27700 = MEM[(const unsigned char *)D.27699];
        D.27701 = (int) D.27700;
        D.27702 = *__s2;
        D.27703 = (int) D.27702;
        __result = D.27701 - D.27703;
        {
          D.27704 = __s2_len != 0;
          D.27705 = __result == 0;
          D.27706 = D.27704 & D.27705;
          if (D.27706 != 0) goto <D.27707>; else goto <D.27708>;
          <D.27707>:
          D.27709 = &MEM[(void *)"SByte" + 1B];
          D.27710 = *D.27709;
          D.27711 = (int) D.27710;
          D.27712 = __s2 + 1;
          D.27713 = *D.27712;
          D.27714 = (int) D.27713;
          __result = D.27711 - D.27714;
          D.27715 = __s2_len > 1;
          D.27705 = __result == 0;
          D.27716 = D.27715 & D.27705;
          if (D.27716 != 0) goto <D.27717>; else goto <D.27718>;
          <D.27717>:
          D.27719 = &MEM[(void *)"SByte" + 2B];
          D.27720 = *D.27719;
          D.27721 = (int) D.27720;
          D.27722 = __s2 + 2;
          D.27723 = *D.27722;
          D.27724 = (int) D.27723;
          __result = D.27721 - D.27724;
          D.27725 = __s2_len > 2;
          D.27705 = __result == 0;
          D.27726 = D.27725 & D.27705;
          if (D.27726 != 0) goto <D.27727>; else goto <D.27728>;
          <D.27727>:
          D.27729 = &MEM[(void *)"SByte" + 3B];
          D.27730 = *D.27729;
          D.27731 = (int) D.27730;
          D.27732 = __s2 + 3;
          D.27733 = *D.27732;
          D.27734 = (int) D.27733;
          __result = D.27731 - D.27734;
          <D.27728>:
          <D.27718>:
          <D.27708>:
        }
        D.20110 = __result;
      }
      iftmp.282 = -D.20110;
      goto <D.27735>;
      <D.27698>:
      iftmp.282 = __builtin_strcmp (name, "SByte");
      <D.27735>:
      D.20111 = iftmp.282;
    }
    if (D.20111 == 0) goto <D.27736>; else goto <D.27737>;
    <D.27736>:
    t = 4;
    class->blittable = 1;
    <D.27737>:
    <D.27695>:
    goto <D.20035>;
    <D.20112>:
    {
      size_t __s1_len;
      size_t __s2_len;

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

        __s2 = name;
        D.27741 = "UInt32";
        D.27742 = MEM[(const unsigned char *)D.27741];
        D.27743 = (int) D.27742;
        D.27744 = *__s2;
        D.27745 = (int) D.27744;
        __result = D.27743 - D.27745;
        {
          D.27746 = __s2_len != 0;
          D.27747 = __result == 0;
          D.27748 = D.27746 & D.27747;
          if (D.27748 != 0) goto <D.27749>; else goto <D.27750>;
          <D.27749>:
          D.27751 = &MEM[(void *)"UInt32" + 1B];
          D.27752 = *D.27751;
          D.27753 = (int) D.27752;
          D.27754 = __s2 + 1;
          D.27755 = *D.27754;
          D.27756 = (int) D.27755;
          __result = D.27753 - D.27756;
          D.27757 = __s2_len > 1;
          D.27747 = __result == 0;
          D.27758 = D.27757 & D.27747;
          if (D.27758 != 0) goto <D.27759>; else goto <D.27760>;
          <D.27759>:
          D.27761 = &MEM[(void *)"UInt32" + 2B];
          D.27762 = *D.27761;
          D.27763 = (int) D.27762;
          D.27764 = __s2 + 2;
          D.27765 = *D.27764;
          D.27766 = (int) D.27765;
          __result = D.27763 - D.27766;
          D.27767 = __s2_len > 2;
          D.27747 = __result == 0;
          D.27768 = D.27767 & D.27747;
          if (D.27768 != 0) goto <D.27769>; else goto <D.27770>;
          <D.27769>:
          D.27771 = &MEM[(void *)"UInt32" + 3B];
          D.27772 = *D.27771;
          D.27773 = (int) D.27772;
          D.27774 = __s2 + 3;
          D.27775 = *D.27774;
          D.27776 = (int) D.27775;
          __result = D.27773 - D.27776;
          <D.27770>:
          <D.27760>:
          <D.27750>:
        }
        D.20120 = __result;
      }
      iftmp.283 = -D.20120;
      goto <D.27777>;
      <D.27740>:
      iftmp.283 = __builtin_strcmp (name, "UInt32");
      <D.27777>:
      D.20121 = iftmp.283;
    }
    if (D.20121 == 0) goto <D.27778>; else goto <D.27779>;
    <D.27778>:
    t = 9;
    class->blittable = 1;
    goto <D.27780>;
    <D.27779>:
    {
      size_t __s1_len;
      size_t __s2_len;

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

        __s2 = name;
        D.27784 = "UInt16";
        D.27785 = MEM[(const unsigned char *)D.27784];
        D.27786 = (int) D.27785;
        D.27787 = *__s2;
        D.27788 = (int) D.27787;
        __result = D.27786 - D.27788;
        {
          D.27789 = __s2_len != 0;
          D.27790 = __result == 0;
          D.27791 = D.27789 & D.27790;
          if (D.27791 != 0) goto <D.27792>; else goto <D.27793>;
          <D.27792>:
          D.27794 = &MEM[(void *)"UInt16" + 1B];
          D.27795 = *D.27794;
          D.27796 = (int) D.27795;
          D.27797 = __s2 + 1;
          D.27798 = *D.27797;
          D.27799 = (int) D.27798;
          __result = D.27796 - D.27799;
          D.27800 = __s2_len > 1;
          D.27790 = __result == 0;
          D.27801 = D.27800 & D.27790;
          if (D.27801 != 0) goto <D.27802>; else goto <D.27803>;
          <D.27802>:
          D.27804 = &MEM[(void *)"UInt16" + 2B];
          D.27805 = *D.27804;
          D.27806 = (int) D.27805;
          D.27807 = __s2 + 2;
          D.27808 = *D.27807;
          D.27809 = (int) D.27808;
          __result = D.27806 - D.27809;
          D.27810 = __s2_len > 2;
          D.27790 = __result == 0;
          D.27811 = D.27810 & D.27790;
          if (D.27811 != 0) goto <D.27812>; else goto <D.27813>;
          <D.27812>:
          D.27814 = &MEM[(void *)"UInt16" + 3B];
          D.27815 = *D.27814;
          D.27816 = (int) D.27815;
          D.27817 = __s2 + 3;
          D.27818 = *D.27817;
          D.27819 = (int) D.27818;
          __result = D.27816 - D.27819;
          <D.27813>:
          <D.27803>:
          <D.27793>:
        }
        D.20129 = __result;
      }
      iftmp.284 = -D.20129;
      goto <D.27820>;
      <D.27783>:
      iftmp.284 = __builtin_strcmp (name, "UInt16");
      <D.27820>:
      D.20130 = iftmp.284;
    }
    if (D.20130 == 0) goto <D.27821>; else goto <D.27822>;
    <D.27821>:
    t = 7;
    class->blittable = 1;
    goto <D.27823>;
    <D.27822>:
    {
      size_t __s1_len;
      size_t __s2_len;

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

        __s2 = name;
        D.27827 = "UInt64";
        D.27828 = MEM[(const unsigned char *)D.27827];
        D.27829 = (int) D.27828;
        D.27830 = *__s2;
        D.27831 = (int) D.27830;
        __result = D.27829 - D.27831;
        {
          D.27832 = __s2_len != 0;
          D.27833 = __result == 0;
          D.27834 = D.27832 & D.27833;
          if (D.27834 != 0) goto <D.27835>; else goto <D.27836>;
          <D.27835>:
          D.27837 = &MEM[(void *)"UInt64" + 1B];
          D.27838 = *D.27837;
          D.27839 = (int) D.27838;
          D.27840 = __s2 + 1;
          D.27841 = *D.27840;
          D.27842 = (int) D.27841;
          __result = D.27839 - D.27842;
          D.27843 = __s2_len > 1;
          D.27833 = __result == 0;
          D.27844 = D.27843 & D.27833;
          if (D.27844 != 0) goto <D.27845>; else goto <D.27846>;
          <D.27845>:
          D.27847 = &MEM[(void *)"UInt64" + 2B];
          D.27848 = *D.27847;
          D.27849 = (int) D.27848;
          D.27850 = __s2 + 2;
          D.27851 = *D.27850;
          D.27852 = (int) D.27851;
          __result = D.27849 - D.27852;
          D.27853 = __s2_len > 2;
          D.27833 = __result == 0;
          D.27854 = D.27853 & D.27833;
          if (D.27854 != 0) goto <D.27855>; else goto <D.27856>;
          <D.27855>:
          D.27857 = &MEM[(void *)"UInt64" + 3B];
          D.27858 = *D.27857;
          D.27859 = (int) D.27858;
          D.27860 = __s2 + 3;
          D.27861 = *D.27860;
          D.27862 = (int) D.27861;
          __result = D.27859 - D.27862;
          <D.27856>:
          <D.27846>:
          <D.27836>:
        }
        D.20138 = __result;
      }
      iftmp.285 = -D.20138;
      goto <D.27863>;
      <D.27826>:
      iftmp.285 = __builtin_strcmp (name, "UInt64");
      <D.27863>:
      D.20139 = iftmp.285;
    }
    if (D.20139 == 0) goto <D.27864>; else goto <D.27865>;
    <D.27864>:
    t = 11;
    class->blittable = 1;
    goto <D.27866>;
    <D.27865>:
    {
      size_t __s1_len;
      size_t __s2_len;

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

        __s2 = name;
        D.27870 = "UIntPtr";
        D.27871 = MEM[(const unsigned char *)D.27870];
        D.27872 = (int) D.27871;
        D.27873 = *__s2;
        D.27874 = (int) D.27873;
        __result = D.27872 - D.27874;
        {
          D.27875 = __s2_len != 0;
          D.27876 = __result == 0;
          D.27877 = D.27875 & D.27876;
          if (D.27877 != 0) goto <D.27878>; else goto <D.27879>;
          <D.27878>:
          D.27880 = &MEM[(void *)"UIntPtr" + 1B];
          D.27881 = *D.27880;
          D.27882 = (int) D.27881;
          D.27883 = __s2 + 1;
          D.27884 = *D.27883;
          D.27885 = (int) D.27884;
          __result = D.27882 - D.27885;
          D.27886 = __s2_len > 1;
          D.27876 = __result == 0;
          D.27887 = D.27886 & D.27876;
          if (D.27887 != 0) goto <D.27888>; else goto <D.27889>;
          <D.27888>:
          D.27890 = &MEM[(void *)"UIntPtr" + 2B];
          D.27891 = *D.27890;
          D.27892 = (int) D.27891;
          D.27893 = __s2 + 2;
          D.27894 = *D.27893;
          D.27895 = (int) D.27894;
          __result = D.27892 - D.27895;
          D.27896 = __s2_len > 2;
          D.27876 = __result == 0;
          D.27897 = D.27896 & D.27876;
          if (D.27897 != 0) goto <D.27898>; else goto <D.27899>;
          <D.27898>:
          D.27900 = &MEM[(void *)"UIntPtr" + 3B];
          D.27901 = *D.27900;
          D.27902 = (int) D.27901;
          D.27903 = __s2 + 3;
          D.27904 = *D.27903;
          D.27905 = (int) D.27904;
          __result = D.27902 - D.27905;
          <D.27899>:
          <D.27889>:
          <D.27879>:
        }
        D.20147 = __result;
      }
      iftmp.286 = -D.20147;
      goto <D.27906>;
      <D.27869>:
      iftmp.286 = __builtin_strcmp (name, "UIntPtr");
      <D.27906>:
      D.20148 = iftmp.286;
    }
    if (D.20148 == 0) goto <D.27907>; else goto <D.27908>;
    <D.27907>:
    t = 25;
    class->blittable = 1;
    <D.27908>:
    <D.27866>:
    <D.27823>:
    <D.27780>:
    goto <D.20035>;
    <D.20149>:
    {
      size_t __s1_len;
      size_t __s2_len;

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

        __s2 = name;
        D.27236 = "TypedReference";
        D.27237 = MEM[(const unsigned char *)D.27236];
        D.27238 = (int) D.27237;
        D.27912 = *__s2;
        D.27913 = (int) D.27912;
        __result = D.27238 - D.27913;
        {
          D.27914 = __s2_len != 0;
          D.27915 = __result == 0;
          D.27916 = D.27914 & D.27915;
          if (D.27916 != 0) goto <D.27917>; else goto <D.27918>;
          <D.27917>:
          D.27246 = &MEM[(void *)"TypedReference" + 1B];
          D.27247 = *D.27246;
          D.27248 = (int) D.27247;
          D.27919 = __s2 + 1;
          D.27920 = *D.27919;
          D.27921 = (int) D.27920;
          __result = D.27248 - D.27921;
          D.27922 = __s2_len > 1;
          D.27915 = __result == 0;
          D.27923 = D.27922 & D.27915;
          if (D.27923 != 0) goto <D.27924>; else goto <D.27925>;
          <D.27924>:
          D.27256 = &MEM[(void *)"TypedReference" + 2B];
          D.27257 = *D.27256;
          D.27258 = (int) D.27257;
          D.27926 = __s2 + 2;
          D.27927 = *D.27926;
          D.27928 = (int) D.27927;
          __result = D.27258 - D.27928;
          D.27929 = __s2_len > 2;
          D.27915 = __result == 0;
          D.27930 = D.27929 & D.27915;
          if (D.27930 != 0) goto <D.27931>; else goto <D.27932>;
          <D.27931>:
          D.27266 = &MEM[(void *)"TypedReference" + 3B];
          D.27267 = *D.27266;
          D.27268 = (int) D.27267;
          D.27933 = __s2 + 3;
          D.27934 = *D.27933;
          D.27935 = (int) D.27934;
          __result = D.27268 - D.27935;
          <D.27932>:
          <D.27925>:
          <D.27918>:
        }
        D.20157 = __result;
      }
      iftmp.287 = -D.20157;
      goto <D.27936>;
      <D.27911>:
      iftmp.287 = __builtin_strcmp (name, "TypedReference");
      <D.27936>:
      D.20158 = iftmp.287;
    }
    if (D.20158 == 0) goto <D.27937>; else goto <D.27938>;
    <D.27937>:
    t = 22;
    class->blittable = 1;
    <D.27938>:
    goto <D.20035>;
    <D.20159>:
    {
      size_t __s1_len;
      size_t __s2_len;

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

        __s2 = name;
        D.27942 = "Void";
        D.27943 = MEM[(const unsigned char *)D.27942];
        D.27944 = (int) D.27943;
        D.27945 = *__s2;
        D.27946 = (int) D.27945;
        __result = D.27944 - D.27946;
        {
          D.27947 = __s2_len != 0;
          D.27948 = __result == 0;
          D.27949 = D.27947 & D.27948;
          if (D.27949 != 0) goto <D.27950>; else goto <D.27951>;
          <D.27950>:
          D.27952 = &MEM[(void *)"Void" + 1B];
          D.27953 = *D.27952;
          D.27954 = (int) D.27953;
          D.27955 = __s2 + 1;
          D.27956 = *D.27955;
          D.27957 = (int) D.27956;
          __result = D.27954 - D.27957;
          D.27958 = __s2_len > 1;
          D.27948 = __result == 0;
          D.27959 = D.27958 & D.27948;
          if (D.27959 != 0) goto <D.27960>; else goto <D.27961>;
          <D.27960>:
          D.27962 = &MEM[(void *)"Void" + 2B];
          D.27963 = *D.27962;
          D.27964 = (int) D.27963;
          D.27965 = __s2 + 2;
          D.27966 = *D.27965;
          D.27967 = (int) D.27966;
          __result = D.27964 - D.27967;
          D.27968 = __s2_len > 2;
          D.27948 = __result == 0;
          D.27969 = D.27968 & D.27948;
          if (D.27969 != 0) goto <D.27970>; else goto <D.27971>;
          <D.27970>:
          D.27972 = &MEM[(void *)"Void" + 3B];
          D.27973 = *D.27972;
          D.27974 = (int) D.27973;
          D.27975 = __s2 + 3;
          D.27976 = *D.27975;
          D.27977 = (int) D.27976;
          __result = D.27974 - D.27977;
          <D.27971>:
          <D.27961>:
          <D.27951>:
        }
        D.20167 = __result;
      }
      iftmp.288 = -D.20167;
      goto <D.27978>;
      <D.27941>:
      iftmp.288 = __builtin_strcmp (name, "Void");
      <D.27978>:
      D.20168 = iftmp.288;
    }
    if (D.20168 == 0) goto <D.27979>; else goto <D.27980>;
    <D.27979>:
    t = 1;
    <D.27980>:
    goto <D.20035>;
    <D.20169>:
    goto <D.20035>;
    <D.20035>:
    <D.27310>:
    <D.27280>:
    D.27981 = (unsigned char) t;
    class->byval_arg.type = D.27981;
    D.27188 = class->byval_arg.type;
    class->this_arg.type = D.27188;
  }
  <D.27278>:
  D.27984 = class->flags;
  D.27985 = D.27984 & 32;
  if (D.27985 != 0) goto <D.27982>; else goto <D.27986>;
  <D.27986>:
  D.27188 = class->byval_arg.type;
  if (D.27188 == 19) goto <D.27982>; else goto <D.27987>;
  <D.27987>:
  D.27188 = class->byval_arg.type;
  if (D.27188 == 30) goto <D.27982>; else goto <D.27983>;
  <D.27982>:
  D.27988 = mono_get_unique_iid (class);
  D.27989 = (short unsigned int) D.27988;
  class->interface_id = D.27989;
  <D.27983>:
}


mono_class_setup_parent (struct MonoClass * class, struct MonoClass * parent)
{
  struct MonoImage * D.27991;
  int iftmp.289;
  int D.20187;
  int iftmp.290;
  int D.20186;
  const char[7] * D.27998;
  unsigned char D.27999;
  int D.28000;
  unsigned char D.28001;
  int D.28002;
  _Bool D.28003;
  _Bool D.28004;
  _Bool D.28005;
  const unsigned char * D.28008;
  unsigned char D.28009;
  int D.28010;
  const unsigned char * D.28011;
  unsigned char D.28012;
  int D.28013;
  _Bool D.28014;
  _Bool D.28015;
  const unsigned char * D.28018;
  unsigned char D.28019;
  int D.28020;
  const unsigned char * D.28021;
  unsigned char D.28022;
  int D.28023;
  _Bool D.28024;
  _Bool D.28025;
  const unsigned char * D.28028;
  unsigned char D.28029;
  int D.28030;
  const unsigned char * D.28031;
  unsigned char D.28032;
  int D.28033;
  const char * D.28035;
  int D.20196;
  int iftmp.291;
  int D.20195;
  const char[7] * D.28043;
  unsigned char D.28044;
  int D.28045;
  unsigned char D.28046;
  int D.28047;
  _Bool D.28048;
  _Bool D.28049;
  _Bool D.28050;
  const unsigned char * D.28053;
  unsigned char D.28054;
  int D.28055;
  const unsigned char * D.28056;
  unsigned char D.28057;
  int D.28058;
  _Bool D.28059;
  _Bool D.28060;
  const unsigned char * D.28063;
  unsigned char D.28064;
  int D.28065;
  const unsigned char * D.28066;
  unsigned char D.28067;
  int D.28068;
  _Bool D.28069;
  _Bool D.28070;
  const unsigned char * D.28073;
  unsigned char D.28074;
  int D.28075;
  const unsigned char * D.28076;
  unsigned char D.28077;
  int D.28078;
  const char * D.28080;
  int D.20205;
  int iftmp.292;
  int D.20204;
  const char[9] * D.28086;
  unsigned char D.28087;
  int D.28088;
  unsigned char D.28089;
  int D.28090;
  _Bool D.28091;
  _Bool D.28092;
  _Bool D.28093;
  const unsigned char * D.28096;
  unsigned char D.28097;
  int D.28098;
  const unsigned char * D.28099;
  unsigned char D.28100;
  int D.28101;
  _Bool D.28102;
  _Bool D.28103;
  const unsigned char * D.28106;
  unsigned char D.28107;
  int D.28108;
  const unsigned char * D.28109;
  unsigned char D.28110;
  int D.28111;
  _Bool D.28112;
  _Bool D.28113;
  const unsigned char * D.28116;
  unsigned char D.28117;
  int D.28118;
  const unsigned char * D.28119;
  unsigned char D.28120;
  int D.28121;
  unsigned int D.28127;
  unsigned int D.28128;
  unsigned char D.28130;
  unsigned int D.28133;
  struct MonoClass * D.28136;
  struct MonoGenericClass * D.28141;
  const char * D.28144;
  <unnamed-unsigned:1> D.28147;
  <unnamed-unsigned:1> D.28148;
  <unnamed-unsigned:1> D.28149;
  unsigned char D.28153;
  unsigned char D.28154;
  char D.28157;
  int D.20214;
  int iftmp.293;
  int D.20213;
  const char[19] * D.28163;
  unsigned char D.28164;
  int D.28165;
  unsigned char D.28166;
  int D.28167;
  _Bool D.28168;
  _Bool D.28169;
  _Bool D.28170;
  const unsigned char * D.28173;
  unsigned char D.28174;
  int D.28175;
  const unsigned char * D.28176;
  unsigned char D.28177;
  int D.28178;
  _Bool D.28179;
  _Bool D.28180;
  const unsigned char * D.28183;
  unsigned char D.28184;
  int D.28185;
  const unsigned char * D.28186;
  unsigned char D.28187;
  int D.28188;
  _Bool D.28189;
  _Bool D.28190;
  const unsigned char * D.28193;
  unsigned char D.28194;
  int D.28195;
  const unsigned char * D.28196;
  unsigned char D.28197;
  int D.28198;
  int D.20223;
  int iftmp.294;
  int D.20222;
  const char[19] * D.28207;
  unsigned char D.28208;
  int D.28209;
  unsigned char D.28210;
  int D.28211;
  _Bool D.28212;
  _Bool D.28213;
  _Bool D.28214;
  const unsigned char * D.28217;
  unsigned char D.28218;
  int D.28219;
  const unsigned char * D.28220;
  unsigned char D.28221;
  int D.28222;
  _Bool D.28223;
  _Bool D.28224;
  const unsigned char * D.28227;
  unsigned char D.28228;
  int D.28229;
  const unsigned char * D.28230;
  unsigned char D.28231;
  int D.28232;
  _Bool D.28233;
  _Bool D.28234;
  const unsigned char * D.28237;
  unsigned char D.28238;
  int D.28239;
  const unsigned char * D.28240;
  unsigned char D.28241;
  int D.28242;
  int D.20232;
  int iftmp.295;
  int D.20231;
  const char[9] * D.28251;
  unsigned char D.28252;
  int D.28253;
  unsigned char D.28254;
  int D.28255;
  _Bool D.28256;
  _Bool D.28257;
  _Bool D.28258;
  const unsigned char * D.28261;
  unsigned char D.28262;
  int D.28263;
  const unsigned char * D.28264;
  unsigned char D.28265;
  int D.28266;
  _Bool D.28267;
  _Bool D.28268;
  const unsigned char * D.28271;
  unsigned char D.28272;
  int D.28273;
  const unsigned char * D.28274;
  unsigned char D.28275;
  int D.28276;
  _Bool D.28277;
  _Bool D.28278;
  const unsigned char * D.28281;
  unsigned char D.28282;
  int D.28283;
  const unsigned char * D.28284;
  unsigned char D.28285;
  int D.28286;
  struct MonoClass * D.28292;
  unsigned char D.28293;
  unsigned char D.28294;
  struct MonoImage * D.28296;
  int D.28297;
  int D.20241;
  int iftmp.296;
  int D.20240;
  const char[10] * D.28302;
  unsigned char D.28303;
  int D.28304;
  unsigned char D.28305;
  int D.28306;
  _Bool D.28307;
  _Bool D.28308;
  _Bool D.28309;
  const unsigned char * D.28312;
  unsigned char D.28313;
  int D.28314;
  const unsigned char * D.28315;
  unsigned char D.28316;
  int D.28317;
  _Bool D.28318;
  _Bool D.28319;
  const unsigned char * D.28322;
  unsigned char D.28323;
  int D.28324;
  const unsigned char * D.28325;
  unsigned char D.28326;
  int D.28327;
  _Bool D.28328;
  _Bool D.28329;
  const unsigned char * D.28332;
  unsigned char D.28333;
  int D.28334;
  const unsigned char * D.28335;
  unsigned char D.28336;
  int D.28337;
  const char * D.28339;
  int D.20250;
  int iftmp.297;
  int D.20249;
  unsigned char D.28344;
  int D.28345;
  _Bool D.28346;
  _Bool D.28347;
  _Bool D.28348;
  const unsigned char * D.28351;
  unsigned char D.28352;
  int D.28353;
  _Bool D.28354;
  _Bool D.28355;
  const unsigned char * D.28358;
  unsigned char D.28359;
  int D.28360;
  _Bool D.28361;
  _Bool D.28362;
  const unsigned char * D.28365;
  unsigned char D.28366;
  int D.28367;
  const char * D.28369;
  int D.28370;
  int D.20259;
  int iftmp.298;
  int D.20258;
  const char[5] * D.28376;
  unsigned char D.28377;
  int D.28378;
  unsigned char D.28379;
  int D.28380;
  _Bool D.28381;
  _Bool D.28382;
  _Bool D.28383;
  const unsigned char * D.28386;
  unsigned char D.28387;
  int D.28388;
  const unsigned char * D.28389;
  unsigned char D.28390;
  int D.28391;
  _Bool D.28392;
  _Bool D.28393;
  const unsigned char * D.28396;
  unsigned char D.28397;
  int D.28398;
  const unsigned char * D.28399;
  unsigned char D.28400;
  int D.28401;
  _Bool D.28402;
  _Bool D.28403;
  const unsigned char * D.28406;
  unsigned char D.28407;
  int D.28408;
  const unsigned char * D.28409;
  unsigned char D.28410;
  int D.28411;
  int D.20268;
  int iftmp.299;
  int D.20267;
  unsigned char D.28418;
  int D.28419;
  _Bool D.28420;
  _Bool D.28421;
  _Bool D.28422;
  const unsigned char * D.28425;
  unsigned char D.28426;
  int D.28427;
  _Bool D.28428;
  _Bool D.28429;
  const unsigned char * D.28432;
  unsigned char D.28433;
  int D.28434;
  _Bool D.28435;
  _Bool D.28436;
  const unsigned char * D.28439;
  unsigned char D.28440;
  int D.28441;
  <unnamed-unsigned:1> D.28445;
  gboolean system_namespace;
  gboolean is_corlib;

  D.27991 = class->image;
  is_corlib = mono_is_corlib_image (D.27991);
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = class->name_space;
      D.27998 = "System";
      D.27999 = MEM[(const unsigned char *)D.27998];
      D.28000 = (int) D.27999;
      D.28001 = *__s2;
      D.28002 = (int) D.28001;
      __result = D.28000 - D.28002;
      {
        D.28003 = __s2_len != 0;
        D.28004 = __result == 0;
        D.28005 = D.28003 & D.28004;
        if (D.28005 != 0) goto <D.28006>; else goto <D.28007>;
        <D.28006>:
        D.28008 = &MEM[(void *)"System" + 1B];
        D.28009 = *D.28008;
        D.28010 = (int) D.28009;
        D.28011 = __s2 + 1;
        D.28012 = *D.28011;
        D.28013 = (int) D.28012;
        __result = D.28010 - D.28013;
        D.28014 = __s2_len > 1;
        D.28004 = __result == 0;
        D.28015 = D.28014 & D.28004;
        if (D.28015 != 0) goto <D.28016>; else goto <D.28017>;
        <D.28016>:
        D.28018 = &MEM[(void *)"System" + 2B];
        D.28019 = *D.28018;
        D.28020 = (int) D.28019;
        D.28021 = __s2 + 2;
        D.28022 = *D.28021;
        D.28023 = (int) D.28022;
        __result = D.28020 - D.28023;
        D.28024 = __s2_len > 2;
        D.28004 = __result == 0;
        D.28025 = D.28024 & D.28004;
        if (D.28025 != 0) goto <D.28026>; else goto <D.28027>;
        <D.28026>:
        D.28028 = &MEM[(void *)"System" + 3B];
        D.28029 = *D.28028;
        D.28030 = (int) D.28029;
        D.28031 = __s2 + 3;
        D.28032 = *D.28031;
        D.28033 = (int) D.28032;
        __result = D.28030 - D.28033;
        <D.28027>:
        <D.28017>:
        <D.28007>:
      }
      D.20186 = __result;
    }
    iftmp.290 = -D.20186;
    goto <D.28034>;
    <D.27997>:
    D.28035 = class->name_space;
    iftmp.290 = __builtin_strcmp (D.28035, "System");
    <D.28034>:
    D.20187 = iftmp.290;
  }
  if (D.20187 == 0) goto <D.28036>; else goto <D.27993>;
  <D.28036>:
  if (is_corlib != 0) goto <D.28037>; else goto <D.27993>;
  <D.28037>:
  iftmp.289 = 1;
  goto <D.27994>;
  <D.27993>:
  iftmp.289 = 0;
  <D.27994>:
  system_namespace = iftmp.289;
  if (system_namespace != 0) goto <D.28038>; else goto <D.28039>;
  <D.28038>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = class->name;
      D.28043 = "Object";
      D.28044 = MEM[(const unsigned char *)D.28043];
      D.28045 = (int) D.28044;
      D.28046 = *__s2;
      D.28047 = (int) D.28046;
      __result = D.28045 - D.28047;
      {
        D.28048 = __s2_len != 0;
        D.28049 = __result == 0;
        D.28050 = D.28048 & D.28049;
        if (D.28050 != 0) goto <D.28051>; else goto <D.28052>;
        <D.28051>:
        D.28053 = &MEM[(void *)"Object" + 1B];
        D.28054 = *D.28053;
        D.28055 = (int) D.28054;
        D.28056 = __s2 + 1;
        D.28057 = *D.28056;
        D.28058 = (int) D.28057;
        __result = D.28055 - D.28058;
        D.28059 = __s2_len > 1;
        D.28049 = __result == 0;
        D.28060 = D.28059 & D.28049;
        if (D.28060 != 0) goto <D.28061>; else goto <D.28062>;
        <D.28061>:
        D.28063 = &MEM[(void *)"Object" + 2B];
        D.28064 = *D.28063;
        D.28065 = (int) D.28064;
        D.28066 = __s2 + 2;
        D.28067 = *D.28066;
        D.28068 = (int) D.28067;
        __result = D.28065 - D.28068;
        D.28069 = __s2_len > 2;
        D.28049 = __result == 0;
        D.28070 = D.28069 & D.28049;
        if (D.28070 != 0) goto <D.28071>; else goto <D.28072>;
        <D.28071>:
        D.28073 = &MEM[(void *)"Object" + 3B];
        D.28074 = *D.28073;
        D.28075 = (int) D.28074;
        D.28076 = __s2 + 3;
        D.28077 = *D.28076;
        D.28078 = (int) D.28077;
        __result = D.28075 - D.28078;
        <D.28072>:
        <D.28062>:
        <D.28052>:
      }
      D.20195 = __result;
    }
    iftmp.291 = -D.20195;
    goto <D.28079>;
    <D.28042>:
    D.28080 = class->name;
    iftmp.291 = __builtin_strcmp (D.28080, "Object");
    <D.28079>:
    D.20196 = iftmp.291;
  }
  if (D.20196 == 0) goto <D.28081>; else goto <D.28082>;
  <D.28081>:
  class->parent = 0B;
  class->instance_size = 8;
  return;
  <D.28082>:
  <D.28039>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = class->name;
      D.28086 = "<Module>";
      D.28087 = MEM[(const unsigned char *)D.28086];
      D.28088 = (int) D.28087;
      D.28089 = *__s2;
      D.28090 = (int) D.28089;
      __result = D.28088 - D.28090;
      {
        D.28091 = __s2_len != 0;
        D.28092 = __result == 0;
        D.28093 = D.28091 & D.28092;
        if (D.28093 != 0) goto <D.28094>; else goto <D.28095>;
        <D.28094>:
        D.28096 = &MEM[(void *)"<Module>" + 1B];
        D.28097 = *D.28096;
        D.28098 = (int) D.28097;
        D.28099 = __s2 + 1;
        D.28100 = *D.28099;
        D.28101 = (int) D.28100;
        __result = D.28098 - D.28101;
        D.28102 = __s2_len > 1;
        D.28092 = __result == 0;
        D.28103 = D.28102 & D.28092;
        if (D.28103 != 0) goto <D.28104>; else goto <D.28105>;
        <D.28104>:
        D.28106 = &MEM[(void *)"<Module>" + 2B];
        D.28107 = *D.28106;
        D.28108 = (int) D.28107;
        D.28109 = __s2 + 2;
        D.28110 = *D.28109;
        D.28111 = (int) D.28110;
        __result = D.28108 - D.28111;
        D.28112 = __s2_len > 2;
        D.28092 = __result == 0;
        D.28113 = D.28112 & D.28092;
        if (D.28113 != 0) goto <D.28114>; else goto <D.28115>;
        <D.28114>:
        D.28116 = &MEM[(void *)"<Module>" + 3B];
        D.28117 = *D.28116;
        D.28118 = (int) D.28117;
        D.28119 = __s2 + 3;
        D.28120 = *D.28119;
        D.28121 = (int) D.28120;
        __result = D.28118 - D.28121;
        <D.28115>:
        <D.28105>:
        <D.28095>:
      }
      D.20204 = __result;
    }
    iftmp.292 = -D.20204;
    goto <D.28122>;
    <D.28085>:
    D.28080 = class->name;
    iftmp.292 = __builtin_strcmp (D.28080, "<Module>");
    <D.28122>:
    D.20205 = iftmp.292;
  }
  if (D.20205 == 0) goto <D.28123>; else goto <D.28124>;
  <D.28123>:
  class->parent = 0B;
  class->instance_size = 0;
  return;
  <D.28124>:
  D.28127 = class->flags;
  D.28128 = D.28127 & 32;
  if (D.28128 == 0) goto <D.28129>; else goto <D.28125>;
  <D.28129>:
  D.28130 = class->byval_arg.type;
  if (D.28130 != 19) goto <D.28131>; else goto <D.28125>;
  <D.28131>:
  D.28130 = class->byval_arg.type;
  if (D.28130 != 30) goto <D.28132>; else goto <D.28125>;
  <D.28132>:
  D.28127 = class->flags;
  D.28133 = D.28127 & 4096;
  if (D.28133 != 0) goto <D.28134>; else goto <D.28135>;
  <D.28134>:
  init_com_from_comimport (class);
  D.28136 = mono_defaults.object_class;
  if (D.28136 == parent) goto <D.28137>; else goto <D.28138>;
  <D.28137>:
  parent = mono_class_get_com_object_class ();
  <D.28138>:
  <D.28135>:
  if (parent == 0B) goto <D.28139>; else goto <D.28140>;
  <D.28139>:
  parent = mono_defaults.object_class;
  mono_class_set_failure (class, 7, 0B);
  <D.28140>:
  class->parent = parent;
  D.28141 = parent->generic_class;
  if (D.28141 != 0B) goto <D.28142>; else goto <D.28143>;
  <D.28142>:
  D.28144 = parent->name;
  if (D.28144 == 0B) goto <D.28145>; else goto <D.28146>;
  <D.28145>:
  return;
  <D.28146>:
  <D.28143>:
  D.28147 = parent->marshalbyref;
  class->marshalbyref = D.28147;
  D.28148 = parent->contextbound;
  class->contextbound = D.28148;
  D.28149 = parent->delegate;
  class->delegate = D.28149;
  D.28127 = class->flags;
  D.28133 = D.28127 & 4096;
  if (D.28133 != 0) goto <D.28150>; else goto <D.28152>;
  <D.28152>:
  D.28153 = BIT_FIELD_REF <*parent, 8, 184>;
  D.28154 = D.28153 & 64;
  if (D.28154 != 0) goto <D.28150>; else goto <D.28151>;
  <D.28150>:
  class->is_com_object = 1;
  <D.28151>:
  if (system_namespace != 0) goto <D.28155>; else goto <D.28156>;
  <D.28155>:
  D.28080 = class->name;
  D.28157 = *D.28080;
  if (D.28157 == 77) goto <D.28158>; else goto <D.28159>;
  <D.28158>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = class->name;
      D.28163 = "MarshalByRefObject";
      D.28164 = MEM[(const unsigned char *)D.28163];
      D.28165 = (int) D.28164;
      D.28166 = *__s2;
      D.28167 = (int) D.28166;
      __result = D.28165 - D.28167;
      {
        D.28168 = __s2_len != 0;
        D.28169 = __result == 0;
        D.28170 = D.28168 & D.28169;
        if (D.28170 != 0) goto <D.28171>; else goto <D.28172>;
        <D.28171>:
        D.28173 = &MEM[(void *)"MarshalByRefObject" + 1B];
        D.28174 = *D.28173;
        D.28175 = (int) D.28174;
        D.28176 = __s2 + 1;
        D.28177 = *D.28176;
        D.28178 = (int) D.28177;
        __result = D.28175 - D.28178;
        D.28179 = __s2_len > 1;
        D.28169 = __result == 0;
        D.28180 = D.28179 & D.28169;
        if (D.28180 != 0) goto <D.28181>; else goto <D.28182>;
        <D.28181>:
        D.28183 = &MEM[(void *)"MarshalByRefObject" + 2B];
        D.28184 = *D.28183;
        D.28185 = (int) D.28184;
        D.28186 = __s2 + 2;
        D.28187 = *D.28186;
        D.28188 = (int) D.28187;
        __result = D.28185 - D.28188;
        D.28189 = __s2_len > 2;
        D.28169 = __result == 0;
        D.28190 = D.28189 & D.28169;
        if (D.28190 != 0) goto <D.28191>; else goto <D.28192>;
        <D.28191>:
        D.28193 = &MEM[(void *)"MarshalByRefObject" + 3B];
        D.28194 = *D.28193;
        D.28195 = (int) D.28194;
        D.28196 = __s2 + 3;
        D.28197 = *D.28196;
        D.28198 = (int) D.28197;
        __result = D.28195 - D.28198;
        <D.28192>:
        <D.28182>:
        <D.28172>:
      }
      D.20213 = __result;
    }
    iftmp.293 = -D.20213;
    goto <D.28199>;
    <D.28162>:
    D.28080 = class->name;
    iftmp.293 = __builtin_strcmp (D.28080, "MarshalByRefObject");
    <D.28199>:
    D.20214 = iftmp.293;
  }
  if (D.20214 == 0) goto <D.28200>; else goto <D.28201>;
  <D.28200>:
  class->marshalbyref = 1;
  <D.28201>:
  <D.28159>:
  D.28080 = class->name;
  D.28157 = *D.28080;
  if (D.28157 == 67) goto <D.28202>; else goto <D.28203>;
  <D.28202>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = class->name;
      D.28207 = "ContextBoundObject";
      D.28208 = MEM[(const unsigned char *)D.28207];
      D.28209 = (int) D.28208;
      D.28210 = *__s2;
      D.28211 = (int) D.28210;
      __result = D.28209 - D.28211;
      {
        D.28212 = __s2_len != 0;
        D.28213 = __result == 0;
        D.28214 = D.28212 & D.28213;
        if (D.28214 != 0) goto <D.28215>; else goto <D.28216>;
        <D.28215>:
        D.28217 = &MEM[(void *)"ContextBoundObject" + 1B];
        D.28218 = *D.28217;
        D.28219 = (int) D.28218;
        D.28220 = __s2 + 1;
        D.28221 = *D.28220;
        D.28222 = (int) D.28221;
        __result = D.28219 - D.28222;
        D.28223 = __s2_len > 1;
        D.28213 = __result == 0;
        D.28224 = D.28223 & D.28213;
        if (D.28224 != 0) goto <D.28225>; else goto <D.28226>;
        <D.28225>:
        D.28227 = &MEM[(void *)"ContextBoundObject" + 2B];
        D.28228 = *D.28227;
        D.28229 = (int) D.28228;
        D.28230 = __s2 + 2;
        D.28231 = *D.28230;
        D.28232 = (int) D.28231;
        __result = D.28229 - D.28232;
        D.28233 = __s2_len > 2;
        D.28213 = __result == 0;
        D.28234 = D.28233 & D.28213;
        if (D.28234 != 0) goto <D.28235>; else goto <D.28236>;
        <D.28235>:
        D.28237 = &MEM[(void *)"ContextBoundObject" + 3B];
        D.28238 = *D.28237;
        D.28239 = (int) D.28238;
        D.28240 = __s2 + 3;
        D.28241 = *D.28240;
        D.28242 = (int) D.28241;
        __result = D.28239 - D.28242;
        <D.28236>:
        <D.28226>:
        <D.28216>:
      }
      D.20222 = __result;
    }
    iftmp.294 = -D.20222;
    goto <D.28243>;
    <D.28206>:
    D.28080 = class->name;
    iftmp.294 = __builtin_strcmp (D.28080, "ContextBoundObject");
    <D.28243>:
    D.20223 = iftmp.294;
  }
  if (D.20223 == 0) goto <D.28244>; else goto <D.28245>;
  <D.28244>:
  class->contextbound = 1;
  <D.28245>:
  <D.28203>:
  D.28080 = class->name;
  D.28157 = *D.28080;
  if (D.28157 == 68) goto <D.28246>; else goto <D.28247>;
  <D.28246>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = class->name;
      D.28251 = "Delegate";
      D.28252 = MEM[(const unsigned char *)D.28251];
      D.28253 = (int) D.28252;
      D.28254 = *__s2;
      D.28255 = (int) D.28254;
      __result = D.28253 - D.28255;
      {
        D.28256 = __s2_len != 0;
        D.28257 = __result == 0;
        D.28258 = D.28256 & D.28257;
        if (D.28258 != 0) goto <D.28259>; else goto <D.28260>;
        <D.28259>:
        D.28261 = &MEM[(void *)"Delegate" + 1B];
        D.28262 = *D.28261;
        D.28263 = (int) D.28262;
        D.28264 = __s2 + 1;
        D.28265 = *D.28264;
        D.28266 = (int) D.28265;
        __result = D.28263 - D.28266;
        D.28267 = __s2_len > 1;
        D.28257 = __result == 0;
        D.28268 = D.28267 & D.28257;
        if (D.28268 != 0) goto <D.28269>; else goto <D.28270>;
        <D.28269>:
        D.28271 = &MEM[(void *)"Delegate" + 2B];
        D.28272 = *D.28271;
        D.28273 = (int) D.28272;
        D.28274 = __s2 + 2;
        D.28275 = *D.28274;
        D.28276 = (int) D.28275;
        __result = D.28273 - D.28276;
        D.28277 = __s2_len > 2;
        D.28257 = __result == 0;
        D.28278 = D.28277 & D.28257;
        if (D.28278 != 0) goto <D.28279>; else goto <D.28280>;
        <D.28279>:
        D.28281 = &MEM[(void *)"Delegate" + 3B];
        D.28282 = *D.28281;
        D.28283 = (int) D.28282;
        D.28284 = __s2 + 3;
        D.28285 = *D.28284;
        D.28286 = (int) D.28285;
        __result = D.28283 - D.28286;
        <D.28280>:
        <D.28270>:
        <D.28260>:
      }
      D.20231 = __result;
    }
    iftmp.295 = -D.20231;
    goto <D.28287>;
    <D.28250>:
    D.28080 = class->name;
    iftmp.295 = __builtin_strcmp (D.28080, "Delegate");
    <D.28287>:
    D.20232 = iftmp.295;
  }
  if (D.20232 == 0) goto <D.28288>; else goto <D.28289>;
  <D.28288>:
  class->delegate = 1;
  <D.28289>:
  <D.28247>:
  <D.28156>:
  D.28292 = class->parent;
  D.28293 = BIT_FIELD_REF <*D.28292, 8, 160>;
  D.28294 = D.28293 & 16;
  if (D.28294 != 0) goto <D.28290>; else goto <D.28295>;
  <D.28295>:
  D.28292 = class->parent;
  D.28296 = D.28292->image;
  D.28297 = mono_is_corlib_image (D.28296);
  if (D.28297 != 0) goto <D.28298>; else goto <D.28291>;
  <D.28298>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      D.28292 = class->parent;
      __s2 = D.28292->name;
      D.28302 = "ValueType";
      D.28303 = MEM[(const unsigned char *)D.28302];
      D.28304 = (int) D.28303;
      D.28305 = *__s2;
      D.28306 = (int) D.28305;
      __result = D.28304 - D.28306;
      {
        D.28307 = __s2_len != 0;
        D.28308 = __result == 0;
        D.28309 = D.28307 & D.28308;
        if (D.28309 != 0) goto <D.28310>; else goto <D.28311>;
        <D.28310>:
        D.28312 = &MEM[(void *)"ValueType" + 1B];
        D.28313 = *D.28312;
        D.28314 = (int) D.28313;
        D.28315 = __s2 + 1;
        D.28316 = *D.28315;
        D.28317 = (int) D.28316;
        __result = D.28314 - D.28317;
        D.28318 = __s2_len > 1;
        D.28308 = __result == 0;
        D.28319 = D.28318 & D.28308;
        if (D.28319 != 0) goto <D.28320>; else goto <D.28321>;
        <D.28320>:
        D.28322 = &MEM[(void *)"ValueType" + 2B];
        D.28323 = *D.28322;
        D.28324 = (int) D.28323;
        D.28325 = __s2 + 2;
        D.28326 = *D.28325;
        D.28327 = (int) D.28326;
        __result = D.28324 - D.28327;
        D.28328 = __s2_len > 2;
        D.28308 = __result == 0;
        D.28329 = D.28328 & D.28308;
        if (D.28329 != 0) goto <D.28330>; else goto <D.28331>;
        <D.28330>:
        D.28332 = &MEM[(void *)"ValueType" + 3B];
        D.28333 = *D.28332;
        D.28334 = (int) D.28333;
        D.28335 = __s2 + 3;
        D.28336 = *D.28335;
        D.28337 = (int) D.28336;
        __result = D.28334 - D.28337;
        <D.28331>:
        <D.28321>:
        <D.28311>:
      }
      D.20240 = __result;
    }
    iftmp.296 = -D.20240;
    goto <D.28338>;
    <D.28301>:
    D.28292 = class->parent;
    D.28339 = D.28292->name;
    iftmp.296 = __builtin_strcmp (D.28339, "ValueType");
    <D.28338>:
    D.20241 = iftmp.296;
  }
  if (D.20241 == 0) goto <D.28340>; else goto <D.28291>;
  <D.28340>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      D.28292 = class->parent;
      __s2 = D.28292->name_space;
      D.27998 = "System";
      D.27999 = MEM[(const unsigned char *)D.27998];
      D.28000 = (int) D.27999;
      D.28344 = *__s2;
      D.28345 = (int) D.28344;
      __result = D.28000 - D.28345;
      {
        D.28346 = __s2_len != 0;
        D.28347 = __result == 0;
        D.28348 = D.28346 & D.28347;
        if (D.28348 != 0) goto <D.28349>; else goto <D.28350>;
        <D.28349>:
        D.28008 = &MEM[(void *)"System" + 1B];
        D.28009 = *D.28008;
        D.28010 = (int) D.28009;
        D.28351 = __s2 + 1;
        D.28352 = *D.28351;
        D.28353 = (int) D.28352;
        __result = D.28010 - D.28353;
        D.28354 = __s2_len > 1;
        D.28347 = __result == 0;
        D.28355 = D.28354 & D.28347;
        if (D.28355 != 0) goto <D.28356>; else goto <D.28357>;
        <D.28356>:
        D.28018 = &MEM[(void *)"System" + 2B];
        D.28019 = *D.28018;
        D.28020 = (int) D.28019;
        D.28358 = __s2 + 2;
        D.28359 = *D.28358;
        D.28360 = (int) D.28359;
        __result = D.28020 - D.28360;
        D.28361 = __s2_len > 2;
        D.28347 = __result == 0;
        D.28362 = D.28361 & D.28347;
        if (D.28362 != 0) goto <D.28363>; else goto <D.28364>;
        <D.28363>:
        D.28028 = &MEM[(void *)"System" + 3B];
        D.28029 = *D.28028;
        D.28030 = (int) D.28029;
        D.28365 = __s2 + 3;
        D.28366 = *D.28365;
        D.28367 = (int) D.28366;
        __result = D.28030 - D.28367;
        <D.28364>:
        <D.28357>:
        <D.28350>:
      }
      D.20249 = __result;
    }
    iftmp.297 = -D.20249;
    goto <D.28368>;
    <D.28343>:
    D.28292 = class->parent;
    D.28369 = D.28292->name_space;
    iftmp.297 = __builtin_strcmp (D.28369, "System");
    <D.28368>:
    D.20250 = iftmp.297;
  }
  if (D.20250 == 0) goto <D.28290>; else goto <D.28291>;
  <D.28290>:
  class->valuetype = 1;
  <D.28291>:
  D.28292 = class->parent;
  D.28296 = D.28292->image;
  D.28370 = mono_is_corlib_image (D.28296);
  if (D.28370 != 0) goto <D.28371>; else goto <D.28372>;
  <D.28371>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      D.28292 = class->parent;
      __s2 = D.28292->name;
      D.28376 = "Enum";
      D.28377 = MEM[(const unsigned char *)D.28376];
      D.28378 = (int) D.28377;
      D.28379 = *__s2;
      D.28380 = (int) D.28379;
      __result = D.28378 - D.28380;
      {
        D.28381 = __s2_len != 0;
        D.28382 = __result == 0;
        D.28383 = D.28381 & D.28382;
        if (D.28383 != 0) goto <D.28384>; else goto <D.28385>;
        <D.28384>:
        D.28386 = &MEM[(void *)"Enum" + 1B];
        D.28387 = *D.28386;
        D.28388 = (int) D.28387;
        D.28389 = __s2 + 1;
        D.28390 = *D.28389;
        D.28391 = (int) D.28390;
        __result = D.28388 - D.28391;
        D.28392 = __s2_len > 1;
        D.28382 = __result == 0;
        D.28393 = D.28392 & D.28382;
        if (D.28393 != 0) goto <D.28394>; else goto <D.28395>;
        <D.28394>:
        D.28396 = &MEM[(void *)"Enum" + 2B];
        D.28397 = *D.28396;
        D.28398 = (int) D.28397;
        D.28399 = __s2 + 2;
        D.28400 = *D.28399;
        D.28401 = (int) D.28400;
        __result = D.28398 - D.28401;
        D.28402 = __s2_len > 2;
        D.28382 = __result == 0;
        D.28403 = D.28402 & D.28382;
        if (D.28403 != 0) goto <D.28404>; else goto <D.28405>;
        <D.28404>:
        D.28406 = &MEM[(void *)"Enum" + 3B];
        D.28407 = *D.28406;
        D.28408 = (int) D.28407;
        D.28409 = __s2 + 3;
        D.28410 = *D.28409;
        D.28411 = (int) D.28410;
        __result = D.28408 - D.28411;
        <D.28405>:
        <D.28395>:
        <D.28385>:
      }
      D.20258 = __result;
    }
    iftmp.298 = -D.20258;
    goto <D.28412>;
    <D.28375>:
    D.28292 = class->parent;
    D.28339 = D.28292->name;
    iftmp.298 = __builtin_strcmp (D.28339, "Enum");
    <D.28412>:
    D.20259 = iftmp.298;
  }
  if (D.20259 == 0) goto <D.28413>; else goto <D.28414>;
  <D.28413>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      D.28292 = class->parent;
      __s2 = D.28292->name_space;
      D.27998 = "System";
      D.27999 = MEM[(const unsigned char *)D.27998];
      D.28000 = (int) D.27999;
      D.28418 = *__s2;
      D.28419 = (int) D.28418;
      __result = D.28000 - D.28419;
      {
        D.28420 = __s2_len != 0;
        D.28421 = __result == 0;
        D.28422 = D.28420 & D.28421;
        if (D.28422 != 0) goto <D.28423>; else goto <D.28424>;
        <D.28423>:
        D.28008 = &MEM[(void *)"System" + 1B];
        D.28009 = *D.28008;
        D.28010 = (int) D.28009;
        D.28425 = __s2 + 1;
        D.28426 = *D.28425;
        D.28427 = (int) D.28426;
        __result = D.28010 - D.28427;
        D.28428 = __s2_len > 1;
        D.28421 = __result == 0;
        D.28429 = D.28428 & D.28421;
        if (D.28429 != 0) goto <D.28430>; else goto <D.28431>;
        <D.28430>:
        D.28018 = &MEM[(void *)"System" + 2B];
        D.28019 = *D.28018;
        D.28020 = (int) D.28019;
        D.28432 = __s2 + 2;
        D.28433 = *D.28432;
        D.28434 = (int) D.28433;
        __result = D.28020 - D.28434;
        D.28435 = __s2_len > 2;
        D.28421 = __result == 0;
        D.28436 = D.28435 & D.28421;
        if (D.28436 != 0) goto <D.28437>; else goto <D.28438>;
        <D.28437>:
        D.28028 = &MEM[(void *)"System" + 3B];
        D.28029 = *D.28028;
        D.28030 = (int) D.28029;
        D.28439 = __s2 + 3;
        D.28440 = *D.28439;
        D.28441 = (int) D.28440;
        __result = D.28030 - D.28441;
        <D.28438>:
        <D.28431>:
        <D.28424>:
      }
      D.20267 = __result;
    }
    iftmp.299 = -D.20267;
    goto <D.28442>;
    <D.28417>:
    D.28292 = class->parent;
    D.28369 = D.28292->name_space;
    iftmp.299 = __builtin_strcmp (D.28369, "System");
    <D.28442>:
    D.20268 = iftmp.299;
  }
  if (D.20268 == 0) goto <D.28443>; else goto <D.28444>;
  <D.28443>:
  class->enumtype = 1;
  D.28445 = class->enumtype;
  class->valuetype = D.28445;
  <D.28444>:
  <D.28414>:
  <D.28372>:
  goto <D.28126>;
  <D.28125>:
  D.28127 = class->flags;
  D.28133 = D.28127 & 4096;
  if (D.28133 != 0) goto <D.28446>; else goto <D.28447>;
  <D.28446>:
  init_com_from_comimport (class);
  <D.28447>:
  class->parent = 0B;
  <D.28126>:
}


init_com_from_comimport (struct MonoClass * class)
{
  <unnamed type> D.28449;
  struct MonoImage * D.28452;
  int D.28453;

  D.28449 = mono_security_get_mode ();
  if (D.28449 == 1) goto <D.28450>; else goto <D.28451>;
  <D.28450>:
  D.28452 = class->image;
  D.28453 = mono_security_core_clr_determine_platform_image (D.28452);
  if (D.28453 == 0) goto <D.28454>; else goto <D.28455>;
  <D.28454>:
  mono_class_set_failure (class, 7, 0B);
  return;
  <D.28455>:
  <D.28451>:
}


mono_class_setup_supertypes (struct MonoClass * class)
{
  struct MonoClass * D.28459;
  struct MonoClass * * D.28462;
  short unsigned int D.28467;
  short unsigned int D.28468;
  int iftmp.300;
  short unsigned int D.28471;
  unsigned int ms.301;
  unsigned int D.28476;
  int D.28477;
  sizetype D.28480;
  sizetype D.28481;
  sizetype D.28482;
  struct MonoClass * * D.28483;
  unsigned int D.28484;
  unsigned int D.28485;
  int ms;
  struct MonoClass * * supertypes;

  {
    void * __tmp;

    __tmp = class->supertypes;
    supertypes = __tmp;
  }
  if (supertypes != 0B) goto <D.28457>; else goto <D.28458>;
  <D.28457>:
  return;
  <D.28458>:
  D.28459 = class->parent;
  if (D.28459 != 0B) goto <D.28460>; else goto <D.28461>;
  <D.28460>:
  D.28459 = class->parent;
  D.28462 = D.28459->supertypes;
  if (D.28462 == 0B) goto <D.28463>; else goto <D.28464>;
  <D.28463>:
  D.28459 = class->parent;
  mono_class_setup_supertypes (D.28459);
  <D.28464>:
  <D.28461>:
  D.28459 = class->parent;
  if (D.28459 != 0B) goto <D.28465>; else goto <D.28466>;
  <D.28465>:
  D.28459 = class->parent;
  D.28467 = D.28459->idepth;
  D.28468 = D.28467 + 1;
  class->idepth = D.28468;
  goto <D.28469>;
  <D.28466>:
  class->idepth = 1;
  <D.28469>:
  D.28471 = class->idepth;
  if (D.28471 > 5) goto <D.28472>; else goto <D.28473>;
  <D.28472>:
  D.28471 = class->idepth;
  iftmp.300 = (int) D.28471;
  goto <D.28474>;
  <D.28473>:
  iftmp.300 = 6;
  <D.28474>:
  ms = iftmp.300;
  ms.301 = (unsigned int) ms;
  D.28476 = ms.301 * 4;
  D.28477 = (int) D.28476;
  supertypes = mono_class_alloc0 (class, D.28477);
  D.28459 = class->parent;
  if (D.28459 != 0B) goto <D.28478>; else goto <D.28479>;
  <D.28478>:
  D.28471 = class->idepth;
  D.28480 = (sizetype) D.28471;
  D.28481 = D.28480 + 1073741823;
  D.28482 = D.28481 * 4;
  D.28483 = supertypes + D.28482;
  *D.28483 = class;
  D.28459 = class->parent;
  D.28467 = D.28459->idepth;
  D.28484 = (unsigned int) D.28467;
  D.28485 = D.28484 * 4;
  D.28459 = class->parent;
  D.28462 = D.28459->supertypes;
  memcpy (supertypes, D.28462, D.28485);
  goto <D.28486>;
  <D.28479>:
  *supertypes = class;
  <D.28486>:
  class->supertypes = supertypes;
}


mono_class_is_nullable (struct MonoClass * klass)
{
  gboolean D.28488;
  int iftmp.302;
  struct MonoGenericClass * D.28492;
  struct MonoClass * D.28494;
  struct MonoClass * D.28495;

  D.28492 = klass->generic_class;
  if (D.28492 != 0B) goto <D.28493>; else goto <D.28490>;
  <D.28493>:
  D.28492 = klass->generic_class;
  D.28494 = D.28492->container_class;
  D.28495 = mono_defaults.generic_nullable_class;
  if (D.28494 == D.28495) goto <D.28496>; else goto <D.28490>;
  <D.28496>:
  iftmp.302 = 1;
  goto <D.28491>;
  <D.28490>:
  iftmp.302 = 0;
  <D.28491>:
  D.28488 = iftmp.302;
  return D.28488;
}


mono_class_get_nullable_param (struct MonoClass * klass)
{
  int D.28498;
  _Bool D.28499;
  long int D.28500;
  long int D.28501;
  struct MonoClass * D.28504;
  struct MonoGenericClass * D.28505;
  struct MonoGenericInst * D.28506;
  struct MonoType * D.28507;

  D.28498 = mono_class_is_nullable (klass);
  D.28499 = D.28498 == 0;
  D.28500 = (long int) D.28499;
  D.28501 = __builtin_expect (D.28500, 0);
  if (D.28501 != 0) goto <D.28502>; else goto <D.28503>;
  <D.28502>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "class.c", 5807, "mono_class_is_nullable (klass)");
  <D.28503>:
  D.28505 = klass->generic_class;
  D.28506 = D.28505->context.class_inst;
  D.28507 = D.28506->type_argv[0];
  D.28504 = mono_class_from_mono_type (D.28507);
  return D.28504;
}


mono_generic_class_get_class (struct MonoGenericClass * gclass)
{
  struct MonoClass * D.28509;
  struct MonoClass * D.28512;
  struct MonoImageSet * D.28515;
  int record_gclass_instantiation.303;
  struct GSList * gclass_recorded_list.304;
  struct GSList * gclass_recorded_list.305;
  struct MonoClass * D.28521;
  const char * D.28524;
  const char * D.28525;
  struct MonoImage * D.28526;
  unsigned int D.28527;
  unsigned int D.28528;
  unsigned int D.28529;
  unsigned char D.28530;
  struct MonoGenericClass * D.28531;
  <unnamed-unsigned:1> D.28532;
  <unnamed-unsigned:1> D.28533;
  struct MonoClass * D.28534;
  int D.28535;
  struct MonoClass * D.28538;
  unsigned char D.28539;
  unsigned char D.28540;
  unsigned char D.28543;
  unsigned char D.28544;
  int D.28547;
  int D.28548;
  unsigned int inflated_classes.306;
  unsigned int inflated_classes.307;
  unsigned int inflated_classes_size.308;
  unsigned int inflated_classes_size.309;
  struct MonoClass * klass;
  struct MonoClass * gklass;

  D.28509 = gclass->cached_class;
  if (D.28509 != 0B) goto <D.28510>; else goto <D.28511>;
  <D.28510>:
  D.28512 = gclass->cached_class;
  return D.28512;
  <D.28511>:
  mono_loader_lock ();
  D.28509 = gclass->cached_class;
  if (D.28509 != 0B) goto <D.28513>; else goto <D.28514>;
  <D.28513>:
  mono_loader_unlock ();
  D.28512 = gclass->cached_class;
  return D.28512;
  <D.28514>:
  D.28515 = gclass->owner;
  klass = mono_image_set_alloc0 (D.28515, 164);
  gklass = gclass->container_class;
  record_gclass_instantiation.303 = record_gclass_instantiation;
  if (record_gclass_instantiation.303 > 0) goto <D.28517>; else goto <D.28518>;
  <D.28517>:
  gclass_recorded_list.304 = gclass_recorded_list;
  gclass_recorded_list.305 = monoeg_g_slist_append (gclass_recorded_list.304, klass);
  gclass_recorded_list = gclass_recorded_list.305;
  <D.28518>:
  D.28521 = gklass->nested_in;
  if (D.28521 != 0B) goto <D.28522>; else goto <D.28523>;
  <D.28522>:
  D.28521 = gklass->nested_in;
  klass->nested_in = D.28521;
  <D.28523>:
  D.28524 = gklass->name;
  klass->name = D.28524;
  D.28525 = gklass->name_space;
  klass->name_space = D.28525;
  mono_profiler_class_event (klass, 0);
  D.28526 = gklass->image;
  klass->image = D.28526;
  D.28527 = gklass->flags;
  klass->flags = D.28527;
  D.28528 = gklass->type_token;
  klass->type_token = D.28528;
  D.28529 = gklass->field.count;
  klass->field.count = D.28529;
  klass->is_inflated = 1;
  klass->generic_class = gclass;
  klass->byval_arg.type = 21;
  D.28530 = klass->byval_arg.type;
  klass->this_arg.type = D.28530;
  klass->byval_arg.data.generic_class = gclass;
  D.28531 = klass->byval_arg.data.generic_class;
  klass->this_arg.data.generic_class = D.28531;
  klass->this_arg.byref = 1;
  D.28532 = gklass->enumtype;
  klass->enumtype = D.28532;
  D.28533 = gklass->valuetype;
  klass->valuetype = D.28533;
  klass->element_class = klass;
  D.28534 = klass->element_class;
  klass->cast_class = D.28534;
  D.28535 = mono_class_is_nullable (klass);
  if (D.28535 != 0) goto <D.28536>; else goto <D.28537>;
  <D.28536>:
  D.28538 = mono_class_get_nullable_param (klass);
  klass->element_class = D.28538;
  D.28534 = klass->element_class;
  klass->cast_class = D.28534;
  <D.28537>:
  mono_generic_class_setup_parent (klass, gklass);
  D.28539 = BIT_FIELD_REF <*gclass, 8, 96>;
  D.28540 = D.28539 & 1;
  if (D.28540 != 0) goto <D.28541>; else goto <D.28542>;
  <D.28541>:
  klass->inited = 1;
  mono_class_setup_supertypes (klass);
  D.28543 = BIT_FIELD_REF <*klass, 8, 160>;
  D.28544 = D.28543 & 16;
  if (D.28544 != 0) goto <D.28545>; else goto <D.28546>;
  <D.28545>:
  D.28547 = gklass->instance_size;
  klass->instance_size = D.28547;
  D.28548 = gklass->sizes.class_size;
  klass->sizes.class_size = D.28548;
  mono_memory_barrier ();
  klass->size_inited = 1;
  <D.28546>:
  <D.28542>:
  mono_memory_barrier ();
  gclass->cached_class = klass;
  mono_profiler_class_loaded (klass, 0);
  inflated_classes.306 = inflated_classes;
  inflated_classes.307 = inflated_classes.306 + 1;
  inflated_classes = inflated_classes.307;
  inflated_classes_size.308 = inflated_classes_size;
  inflated_classes_size.309 = inflated_classes_size.308 + 164;
  inflated_classes_size = inflated_classes_size.309;
  mono_loader_unlock ();
  D.28512 = klass;
  return D.28512;
}


mono_class_from_generic_parameter (struct MonoGenericParam * param, struct MonoImage * image, gboolean is_mvar)
{
  struct MonoGenericParamInfo * iftmp.310;
  struct MonoGenericContainer * D.28557;
  struct MonoClass * D.28561;
  struct MonoClass * D.28564;
  _Bool D.28568;
  _Bool D.28569;
  _Bool D.28570;
  struct MonoImage * iftmp.311;
  struct MonoClass * D.28579;
  struct MonoImage * iftmp.312;
  struct MonoGenericContainer * container;
  struct MonoGenericParamInfo * pinfo;
  struct MonoClass * klass;

  container = param->owner;
  mono_loader_lock ();
  if (container != 0B) goto <D.28554>; else goto <D.28555>;
  <D.28554>:
  D.28557 = param->owner;
  if (D.28557 != 0B) goto <D.28558>; else goto <D.28559>;
  <D.28558>:
  iftmp.310 = &MEM[(struct MonoGenericParamFull *)param].info;
  goto <D.28560>;
  <D.28559>:
  iftmp.310 = 0B;
  <D.28560>:
  pinfo = iftmp.310;
  D.28561 = pinfo->pklass;
  if (D.28561 != 0B) goto <D.28562>; else goto <D.28563>;
  <D.28562>:
  mono_loader_unlock ();
  D.28564 = pinfo->pklass;
  return D.28564;
  <D.28563>:
  goto <D.28565>;
  <D.28555>:
  pinfo = 0B;
  image = 0B;
  klass = get_anon_gparam_class (param, is_mvar);
  if (klass != 0B) goto <D.28566>; else goto <D.28567>;
  <D.28566>:
  mono_loader_unlock ();
  D.28564 = klass;
  return D.28564;
  <D.28567>:
  <D.28565>:
  D.28568 = image == 0B;
  D.28569 = container != 0B;
  D.28570 = D.28568 & D.28569;
  if (D.28570 != 0) goto <D.28571>; else goto <D.28572>;
  <D.28571>:
  if (is_mvar != 0) goto <D.28573>; else goto <D.28574>;
  <D.28573>:
  {
    struct MonoMethod * method;

    method = container->owner.method;
    if (method != 0B) goto <D.28578>; else goto <D.28576>;
    <D.28578>:
    D.28579 = method->klass;
    if (D.28579 != 0B) goto <D.28580>; else goto <D.28576>;
    <D.28580>:
    D.28579 = method->klass;
    iftmp.311 = D.28579->image;
    goto <D.28577>;
    <D.28576>:
    iftmp.311 = 0B;
    <D.28577>:
    image = iftmp.311;
  }
  goto <D.28581>;
  <D.28574>:
  {
    struct MonoClass * klass;

    klass = container->owner.klass;
    if (klass != 0B) goto <D.28583>; else goto <D.28584>;
    <D.28583>:
    iftmp.312 = klass->image;
    goto <D.28585>;
    <D.28584>:
    iftmp.312 = 0B;
    <D.28585>:
    image = iftmp.312;
  }
  <D.28581>:
  <D.28572>:
  klass = make_generic_param_class (param, image, is_mvar, pinfo);
  mono_memory_barrier ();
  if (container != 0B) goto <D.28586>; else goto <D.28587>;
  <D.28586>:
  pinfo->pklass = klass;
  goto <D.28588>;
  <D.28587>:
  set_anon_gparam_class (param, is_mvar, klass);
  <D.28588>:
  mono_loader_unlock ();
  mono_profiler_class_loaded (klass, 0);
  D.28564 = klass;
  return D.28564;
}


get_anon_gparam_class (struct MonoGenericParam * param, gboolean is_mvar)
{
  short unsigned int D.28590;
  unsigned int D.28591;
  short unsigned int D.28592;
  unsigned int D.28593;
  unsigned int D.28594;
  unsigned int D.28595;
  _Bool D.28596;
  long int D.28597;
  long int D.28598;
  struct MonoClass * D.28605;
  struct MonoClass * iftmp.313;
  struct MonoClass * * D.28607;
  unsigned int n.314;
  unsigned int D.28611;
  struct MonoClass * * D.28612;
  struct MonoClass * iftmp.315;
  struct MonoClass * * D.28615;
  struct MonoClass * * D.28618;
  struct GHashTable * iftmp.316;
  struct MonoClass * iftmp.317;
  const void * n.318;
  int n;
  struct MonoImage * image;
  struct GHashTable * ht;

  D.28590 = param->num;
  D.28591 = (unsigned int) D.28590;
  D.28592 = param->serial;
  D.28593 = (unsigned int) D.28592;
  D.28594 = D.28593 << 16;
  D.28595 = D.28591 | D.28594;
  n = (int) D.28595;
  image = param->image;
  D.28596 = image == 0B;
  D.28597 = (long int) D.28596;
  D.28598 = __builtin_expect (D.28597, 0);
  if (D.28598 != 0) goto <D.28599>; else goto <D.28600>;
  <D.28599>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "class.c", 6028, "image");
  <D.28600>:
  if (n <= 15) goto <D.28601>; else goto <D.28602>;
  <D.28601>:
  if (is_mvar != 0) goto <D.28603>; else goto <D.28604>;
  <D.28603>:
  D.28607 = image->mvar_cache_fast;
  if (D.28607 != 0B) goto <D.28608>; else goto <D.28609>;
  <D.28608>:
  D.28607 = image->mvar_cache_fast;
  n.314 = (unsigned int) n;
  D.28611 = n.314 * 4;
  D.28612 = D.28607 + D.28611;
  iftmp.313 = *D.28612;
  goto <D.28613>;
  <D.28609>:
  iftmp.313 = 0B;
  <D.28613>:
  D.28605 = iftmp.313;
  return D.28605;
  <D.28604>:
  D.28615 = image->var_cache_fast;
  if (D.28615 != 0B) goto <D.28616>; else goto <D.28617>;
  <D.28616>:
  D.28615 = image->var_cache_fast;
  n.314 = (unsigned int) n;
  D.28611 = n.314 * 4;
  D.28618 = D.28615 + D.28611;
  iftmp.315 = *D.28618;
  goto <D.28619>;
  <D.28617>:
  iftmp.315 = 0B;
  <D.28619>:
  D.28605 = iftmp.315;
  return D.28605;
  <D.28602>:
  if (is_mvar != 0) goto <D.28621>; else goto <D.28622>;
  <D.28621>:
  iftmp.316 = image->mvar_cache_slow;
  goto <D.28623>;
  <D.28622>:
  iftmp.316 = image->var_cache_slow;
  <D.28623>:
  ht = iftmp.316;
  if (ht != 0B) goto <D.28625>; else goto <D.28626>;
  <D.28625>:
  n.318 = (const void *) n;
  iftmp.317 = monoeg_g_hash_table_lookup (ht, n.318);
  goto <D.28628>;
  <D.28626>:
  iftmp.317 = 0B;
  <D.28628>:
  D.28605 = iftmp.317;
  return D.28605;
}


make_generic_param_class (struct MonoGenericParam * param, struct MonoImage * image, gboolean is_mvar, struct MonoGenericParamInfo * pinfo)
{
  unsigned int classes_size.319;
  unsigned int classes_size.320;
  const char * D.28636;
  short unsigned int D.28638;
  void * D.28639;
  const char * D.28640;
  const char * iftmp.321;
  struct MonoClass * D.28649;
  const char * iftmp.322;
  struct MonoClass * D.28660;
  struct MonoClass * * D.28664;
  struct MonoClass * D.28665;
  unsigned int D.28666;
  unsigned int D.28667;
  unsigned char D.28669;
  short unsigned int D.28675;
  int D.28676;
  int D.28677;
  struct MonoImage * D.28679;
  struct MonoClass * D.28680;
  struct MonoClass * D.28681;
  int D.28682;
  short unsigned int D.28685;
  short unsigned int D.28686;
  short unsigned int D.28687;
  unsigned int D.28688;
  unsigned int D.28689;
  void * D.28690;
  struct MonoClass * * D.28691;
  int D.28692;
  unsigned int D.28693;
  unsigned int D.28694;
  struct MonoClass * * D.28695;
  unsigned int i.323;
  unsigned int D.28697;
  struct MonoClass * * D.28698;
  struct MonoClass * D.28699;
  struct MonoClass * D.28700;
  unsigned char iftmp.324;
  unsigned char D.28705;
  struct MonoGenericParam * D.28706;
  int iftmp.325;
  unsigned int D.28710;
  struct MonoClass * D.28714;
  unsigned char D.28715;
  gchar * D.28718;
  int D.28720;
  struct MonoClass * D.28721;
  struct MonoClass * klass;
  struct MonoClass * * ptr;
  int count;
  int pos;
  int i;
  struct MonoGenericContainer * container;

  container = param->owner;
  if (image == 0B) goto <D.28630>; else goto <D.28631>;
  <D.28630>:
  image = mono_defaults.corlib;
  <D.28631>:
  klass = mono_image_alloc0 (image, 164);
  classes_size.319 = classes_size;
  classes_size.320 = classes_size.319 + 164;
  classes_size = classes_size.320;
  if (pinfo != 0B) goto <D.28634>; else goto <D.28635>;
  <D.28634>:
  D.28636 = pinfo->name;
  klass->name = D.28636;
  goto <D.28637>;
  <D.28635>:
  {
    int n;

    D.28638 = param->num;
    n = (int) D.28638;
    D.28639 = mono_image_alloc0 (image, 16);
    klass->name = D.28639;
    D.28640 = klass->name;
    sprintf (D.28640, "%d", n);
  }
  <D.28637>:
  if (container != 0B) goto <D.28641>; else goto <D.28642>;
  <D.28641>:
  if (is_mvar != 0) goto <D.28643>; else goto <D.28644>;
  <D.28643>:
  {
    struct MonoMethod * omethod;

    omethod = container->owner.method;
    if (omethod != 0B) goto <D.28648>; else goto <D.28646>;
    <D.28648>:
    D.28649 = omethod->klass;
    if (D.28649 != 0B) goto <D.28650>; else goto <D.28646>;
    <D.28650>:
    D.28649 = omethod->klass;
    iftmp.321 = D.28649->name_space;
    goto <D.28647>;
    <D.28646>:
    iftmp.321 = "";
    <D.28647>:
    klass->name_space = iftmp.321;
  }
  goto <D.28651>;
  <D.28644>:
  {
    struct MonoClass * oklass;

    oklass = container->owner.klass;
    if (oklass != 0B) goto <D.28653>; else goto <D.28654>;
    <D.28653>:
    iftmp.322 = oklass->name_space;
    goto <D.28655>;
    <D.28654>:
    iftmp.322 = "";
    <D.28655>:
    klass->name_space = iftmp.322;
  }
  <D.28651>:
  goto <D.28656>;
  <D.28642>:
  klass->name_space = "";
  <D.28656>:
  mono_profiler_class_event (klass, 0);
  count = 0;
  if (pinfo != 0B) goto <D.28657>; else goto <D.28658>;
  <D.28657>:
  ptr = pinfo->constraints;
  goto <D.20485>;
  <D.20484>:
  ptr = ptr + 4;
  count = count + 1;
  <D.20485>:
  if (ptr != 0B) goto <D.28659>; else goto <D.20486>;
  <D.28659>:
  D.28660 = *ptr;
  if (D.28660 != 0B) goto <D.20484>; else goto <D.20486>;
  <D.20486>:
  <D.28658>:
  pos = 0;
  if (count > 0) goto <D.28663>; else goto <D.28661>;
  <D.28663>:
  D.28664 = pinfo->constraints;
  D.28665 = *D.28664;
  D.28666 = D.28665->flags;
  D.28667 = D.28666 & 32;
  if (D.28667 == 0) goto <D.28668>; else goto <D.28661>;
  <D.28668>:
  D.28664 = pinfo->constraints;
  D.28665 = *D.28664;
  D.28669 = D.28665->byval_arg.type;
  if (D.28669 != 19) goto <D.28670>; else goto <D.28661>;
  <D.28670>:
  D.28664 = pinfo->constraints;
  D.28665 = *D.28664;
  D.28669 = D.28665->byval_arg.type;
  if (D.28669 != 30) goto <D.28671>; else goto <D.28661>;
  <D.28671>:
  D.28664 = pinfo->constraints;
  D.28665 = *D.28664;
  klass->parent = D.28665;
  pos = pos + 1;
  goto <D.28662>;
  <D.28661>:
  if (pinfo != 0B) goto <D.28674>; else goto <D.28672>;
  <D.28674>:
  D.28675 = pinfo->flags;
  D.28676 = (int) D.28675;
  D.28677 = D.28676 & 8;
  if (D.28677 != 0) goto <D.28678>; else goto <D.28672>;
  <D.28678>:
  D.28679 = mono_defaults.corlib;
  D.28680 = mono_class_from_name (D.28679, "System", "ValueType");
  klass->parent = D.28680;
  goto <D.28673>;
  <D.28672>:
  D.28681 = mono_defaults.object_class;
  klass->parent = D.28681;
  <D.28673>:
  <D.28662>:
  D.28682 = count - pos;
  if (D.28682 > 0) goto <D.28683>; else goto <D.28684>;
  <D.28683>:
  D.28685 = (short unsigned int) count;
  D.28686 = (short unsigned int) pos;
  D.28687 = D.28685 - D.28686;
  klass->interface_count = D.28687;
  D.28682 = count - pos;
  D.28688 = (unsigned int) D.28682;
  D.28689 = D.28688 * 4;
  D.28690 = mono_image_alloc0 (image, D.28689);
  klass->interfaces = D.28690;
  klass->interfaces_inited = 1;
  i = pos;
  goto <D.20488>;
  <D.20487>:
  D.28691 = klass->interfaces;
  D.28692 = i - pos;
  D.28693 = (unsigned int) D.28692;
  D.28694 = D.28693 * 4;
  D.28695 = D.28691 + D.28694;
  D.28664 = pinfo->constraints;
  i.323 = (unsigned int) i;
  D.28697 = i.323 * 4;
  D.28698 = D.28664 + D.28697;
  D.28699 = *D.28698;
  *D.28695 = D.28699;
  i = i + 1;
  <D.20488>:
  if (i < count) goto <D.20487>; else goto <D.20489>;
  <D.20489>:
  <D.28684>:
  klass->image = image;
  klass->inited = 1;
  klass->element_class = klass;
  D.28700 = klass->element_class;
  klass->cast_class = D.28700;
  klass->flags = 1;
  if (is_mvar != 0) goto <D.28702>; else goto <D.28703>;
  <D.28702>:
  iftmp.324 = 30;
  goto <D.28704>;
  <D.28703>:
  iftmp.324 = 19;
  <D.28704>:
  klass->byval_arg.type = iftmp.324;
  D.28705 = klass->byval_arg.type;
  klass->this_arg.type = D.28705;
  klass->byval_arg.data.generic_param = param;
  D.28706 = klass->byval_arg.data.generic_param;
  klass->this_arg.data.generic_param = D.28706;
  klass->this_arg.byref = 1;
  if (pinfo != 0B) goto <D.28708>; else goto <D.28709>;
  <D.28708>:
  D.28710 = pinfo->token;
  iftmp.325 = (int) D.28710;
  goto <D.28711>;
  <D.28709>:
  iftmp.325 = 0;
  <D.28711>:
  klass->sizes.generic_param_token = iftmp.325;
  klass->min_align = 1;
  klass->instance_size = 4;
  mono_memory_barrier ();
  klass->size_inited = 1;
  mono_class_setup_supertypes (klass);
  D.28682 = count - pos;
  if (D.28682 > 0) goto <D.28712>; else goto <D.28713>;
  <D.28712>:
  D.28714 = klass->parent;
  mono_class_setup_vtable (D.28714);
  D.28714 = klass->parent;
  D.28715 = D.28714->exception_type;
  if (D.28715 != 0) goto <D.28716>; else goto <D.28717>;
  <D.28716>:
  D.28718 = monoeg_strdup ("Failed to setup parent interfaces");
  mono_class_set_failure (klass, 7, D.28718);
  goto <D.28719>;
  <D.28717>:
  D.28714 = klass->parent;
  D.28720 = D.28714->vtable_size;
  setup_interface_offsets (klass, D.28720, 1);
  <D.28719>:
  <D.28713>:
  D.28721 = klass;
  return D.28721;
}


sprintf (char * restrict __s, const char * restrict __fmt)
{
  int D.28723;
  unsigned int D.28724;

  D.28724 = __builtin_object_size (__s, 1);
  D.28723 = __builtin___sprintf_chk (__s, 1, D.28724, __fmt, __builtin_va_arg_pack ());
  return D.28723;
}


set_anon_gparam_class (struct MonoGenericParam * param, gboolean is_mvar, struct MonoClass * klass)
{
  short unsigned int D.28726;
  unsigned int D.28727;
  short unsigned int D.28728;
  unsigned int D.28729;
  unsigned int D.28730;
  unsigned int D.28731;
  _Bool D.28732;
  long int D.28733;
  long int D.28734;
  struct MonoClass * * D.28741;
  void * D.28744;
  unsigned int n.326;
  unsigned int D.28746;
  struct MonoClass * * D.28747;
  struct MonoClass * * D.28749;
  void * D.28752;
  struct MonoClass * * D.28753;
  struct GHashTable * iftmp.327;
  struct GHashTable * iftmp.328;
  void * n.329;
  int n;
  struct MonoImage * image;
  struct GHashTable * ht;

  D.28726 = param->num;
  D.28727 = (unsigned int) D.28726;
  D.28728 = param->serial;
  D.28729 = (unsigned int) D.28728;
  D.28730 = D.28729 << 16;
  D.28731 = D.28727 | D.28730;
  n = (int) D.28731;
  image = param->image;
  D.28732 = image == 0B;
  D.28733 = (long int) D.28732;
  D.28734 = __builtin_expect (D.28733, 0);
  if (D.28734 != 0) goto <D.28735>; else goto <D.28736>;
  <D.28735>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "class.c", 6051, "image");
  <D.28736>:
  if (n <= 15) goto <D.28737>; else goto <D.28738>;
  <D.28737>:
  if (is_mvar != 0) goto <D.28739>; else goto <D.28740>;
  <D.28739>:
  D.28741 = image->mvar_cache_fast;
  if (D.28741 == 0B) goto <D.28742>; else goto <D.28743>;
  <D.28742>:
  D.28744 = mono_image_alloc0 (image, 64);
  image->mvar_cache_fast = D.28744;
  <D.28743>:
  D.28741 = image->mvar_cache_fast;
  n.326 = (unsigned int) n;
  D.28746 = n.326 * 4;
  D.28747 = D.28741 + D.28746;
  *D.28747 = klass;
  goto <D.28748>;
  <D.28740>:
  D.28749 = image->var_cache_fast;
  if (D.28749 == 0B) goto <D.28750>; else goto <D.28751>;
  <D.28750>:
  D.28752 = mono_image_alloc0 (image, 64);
  image->var_cache_fast = D.28752;
  <D.28751>:
  D.28749 = image->var_cache_fast;
  n.326 = (unsigned int) n;
  D.28746 = n.326 * 4;
  D.28753 = D.28749 + D.28746;
  *D.28753 = klass;
  <D.28748>:
  return;
  <D.28738>:
  if (is_mvar != 0) goto <D.28755>; else goto <D.28756>;
  <D.28755>:
  iftmp.327 = image->mvar_cache_slow;
  goto <D.28757>;
  <D.28756>:
  iftmp.327 = image->var_cache_slow;
  <D.28757>:
  ht = iftmp.327;
  if (ht == 0B) goto <D.28758>; else goto <D.28759>;
  <D.28758>:
  mono_loader_lock ();
  if (is_mvar != 0) goto <D.28761>; else goto <D.28762>;
  <D.28761>:
  iftmp.328 = image->mvar_cache_slow;
  goto <D.28763>;
  <D.28762>:
  iftmp.328 = image->var_cache_slow;
  <D.28763>:
  ht = iftmp.328;
  if (ht == 0B) goto <D.28764>; else goto <D.28765>;
  <D.28764>:
  ht = monoeg_g_hash_table_new (0B, 0B);
  mono_memory_barrier ();
  if (is_mvar != 0) goto <D.28766>; else goto <D.28767>;
  <D.28766>:
  image->mvar_cache_slow = ht;
  goto <D.28768>;
  <D.28767>:
  image->var_cache_slow = ht;
  <D.28768>:
  <D.28765>:
  mono_loader_unlock ();
  <D.28759>:
  n.329 = (void *) n;
  monoeg_g_hash_table_insert_replace (ht, n.329, klass, 0);
}


mono_ptr_class_get (struct MonoType * type)
{
  struct GHashTable * D.28771;
  struct GHashTable * D.28774;
  struct MonoClass * D.28777;
  unsigned int classes_size.330;
  unsigned int classes_size.331;
  const char * D.28780;
  const char * D.28781;
  char * D.28782;
  struct MonoImage * D.28783;
  unsigned int D.28784;
  unsigned int D.28785;
  struct MonoClass * D.28786;
  unsigned char D.28787;
  struct MonoType * D.28788;
  struct MonoType * D.28789;
  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.28771 = image->ptr_cache;
  if (D.28771 == 0B) goto <D.28772>; else goto <D.28773>;
  <D.28772>:
  D.28774 = monoeg_g_hash_table_new (mono_aligned_addr_hash, 0B);
  image->ptr_cache = D.28774;
  <D.28773>:
  D.28771 = image->ptr_cache;
  result = monoeg_g_hash_table_lookup (D.28771, el_class);
  if (result != 0B) goto <D.28775>; else goto <D.28776>;
  <D.28775>:
  mono_loader_unlock ();
  D.28777 = result;
  return D.28777;
  <D.28776>:
  result = mono_image_alloc0 (image, 164);
  classes_size.330 = classes_size;
  classes_size.331 = classes_size.330 + 164;
  classes_size = classes_size.331;
  result->parent = 0B;
  D.28780 = el_class->name_space;
  result->name_space = D.28780;
  D.28781 = el_class->name;
  name = monoeg_g_strdup_printf ("%s*", D.28781);
  D.28782 = mono_image_strdup (image, name);
  result->name = D.28782;
  monoeg_g_free (name);
  mono_profiler_class_event (result, 0);
  D.28783 = el_class->image;
  result->image = D.28783;
  result->inited = 1;
  D.28784 = el_class->flags;
  D.28785 = D.28784 & 7;
  result->flags = D.28785;
  result->instance_size = 4;
  result->element_class = el_class;
  D.28786 = result->element_class;
  result->cast_class = D.28786;
  result->blittable = 1;
  result->byval_arg.type = 15;
  D.28787 = result->byval_arg.type;
  result->this_arg.type = D.28787;
  D.28786 = result->element_class;
  D.28788 = &D.28786->byval_arg;
  result->byval_arg.data.type = D.28788;
  D.28789 = result->byval_arg.data.type;
  result->this_arg.data.type = D.28789;
  result->this_arg.byref = 1;
  mono_class_setup_supertypes (result);
  D.28771 = image->ptr_cache;
  monoeg_g_hash_table_insert_replace (D.28771, el_class, result, 0);
  mono_loader_unlock ();
  mono_profiler_class_loaded (result, 0);
  D.28777 = result;
  return D.28777;
}


mono_class_from_mono_type (struct MonoType * type)
{
  unsigned char D.28791;
  int D.28792;
  struct MonoClass * D.28793;
  struct MonoClass * iftmp.332;
  struct MonoClass * D.28795;
  struct MonoClass * iftmp.333;
  struct MonoClass * iftmp.334;
  struct MonoClass * iftmp.335;
  struct MonoClass * iftmp.336;
  struct MonoClass * iftmp.337;
  struct MonoClass * iftmp.338;
  struct MonoClass * iftmp.339;
  struct MonoClass * iftmp.340;
  struct MonoClass * iftmp.341;
  struct MonoClass * iftmp.342;
  struct MonoClass * iftmp.343;
  struct MonoClass * iftmp.344;
  struct MonoClass * iftmp.345;
  struct MonoClass * iftmp.346;
  struct MonoClass * iftmp.347;
  struct MonoClass * iftmp.348;
  struct MonoClass * iftmp.349;
  struct MonoArrayType * D.28867;
  unsigned char D.28868;
  unsigned int D.28869;
  struct MonoClass * D.28870;
  struct MonoType * D.28871;
  struct MonoMethodSignature * D.28872;
  struct MonoGenericClass * D.28873;
  struct MonoGenericParam * D.28874;

  D.28791 = type->type;
  D.28792 = (int) D.28791;
  switch (D.28792) <default: <D.20557>, case 1: <D.20531>, case 2: <D.20532>, case 3: <D.20533>, case 4: <D.20534>, case 5: <D.20535>, case 6: <D.20536>, case 7: <D.20537>, case 8: <D.20538>, case 9: <D.20539>, case 10: <D.20542>, case 11: <D.20543>, case 12: <D.20544>, case 13: <D.20545>, case 14: <D.20546>, case 15: <D.20549>, case 17: <D.20553>, case 18: <D.20552>, case 19: <D.20555>, case 20: <D.20548>, case 21: <D.20554>, case 22: <D.20547>, case 24: <D.20540>, case 25: <D.20541>, case 27: <D.20550>, case 28: <D.20530>, case 29: <D.20551>, case 30: <D.20556>>
  <D.20530>:
  D.28795 = type->data.klass;
  if (D.28795 != 0B) goto <D.28796>; else goto <D.28797>;
  <D.28796>:
  iftmp.332 = type->data.klass;
  goto <D.28798>;
  <D.28797>:
  iftmp.332 = mono_defaults.object_class;
  <D.28798>:
  D.28793 = iftmp.332;
  return D.28793;
  <D.20531>:
  D.28795 = type->data.klass;
  if (D.28795 != 0B) goto <D.28800>; else goto <D.28801>;
  <D.28800>:
  iftmp.333 = type->data.klass;
  goto <D.28802>;
  <D.28801>:
  iftmp.333 = mono_defaults.void_class;
  <D.28802>:
  D.28793 = iftmp.333;
  return D.28793;
  <D.20532>:
  D.28795 = type->data.klass;
  if (D.28795 != 0B) goto <D.28804>; else goto <D.28805>;
  <D.28804>:
  iftmp.334 = type->data.klass;
  goto <D.28806>;
  <D.28805>:
  iftmp.334 = mono_defaults.boolean_class;
  <D.28806>:
  D.28793 = iftmp.334;
  return D.28793;
  <D.20533>:
  D.28795 = type->data.klass;
  if (D.28795 != 0B) goto <D.28808>; else goto <D.28809>;
  <D.28808>:
  iftmp.335 = type->data.klass;
  goto <D.28810>;
  <D.28809>:
  iftmp.335 = mono_defaults.char_class;
  <D.28810>:
  D.28793 = iftmp.335;
  return D.28793;
  <D.20534>:
  D.28795 = type->data.klass;
  if (D.28795 != 0B) goto <D.28812>; else goto <D.28813>;
  <D.28812>:
  iftmp.336 = type->data.klass;
  goto <D.28814>;
  <D.28813>:
  iftmp.336 = mono_defaults.sbyte_class;
  <D.28814>:
  D.28793 = iftmp.336;
  return D.28793;
  <D.20535>:
  D.28795 = type->data.klass;
  if (D.28795 != 0B) goto <D.28816>; else goto <D.28817>;
  <D.28816>:
  iftmp.337 = type->data.klass;
  goto <D.28818>;
  <D.28817>:
  iftmp.337 = mono_defaults.byte_class;
  <D.28818>:
  D.28793 = iftmp.337;
  return D.28793;
  <D.20536>:
  D.28795 = type->data.klass;
  if (D.28795 != 0B) goto <D.28820>; else goto <D.28821>;
  <D.28820>:
  iftmp.338 = type->data.klass;
  goto <D.28822>;
  <D.28821>:
  iftmp.338 = mono_defaults.int16_class;
  <D.28822>:
  D.28793 = iftmp.338;
  return D.28793;
  <D.20537>:
  D.28795 = type->data.klass;
  if (D.28795 != 0B) goto <D.28824>; else goto <D.28825>;
  <D.28824>:
  iftmp.339 = type->data.klass;
  goto <D.28826>;
  <D.28825>:
  iftmp.339 = mono_defaults.uint16_class;
  <D.28826>:
  D.28793 = iftmp.339;
  return D.28793;
  <D.20538>:
  D.28795 = type->data.klass;
  if (D.28795 != 0B) goto <D.28828>; else goto <D.28829>;
  <D.28828>:
  iftmp.340 = type->data.klass;
  goto <D.28830>;
  <D.28829>:
  iftmp.340 = mono_defaults.int32_class;
  <D.28830>:
  D.28793 = iftmp.340;
  return D.28793;
  <D.20539>:
  D.28795 = type->data.klass;
  if (D.28795 != 0B) goto <D.28832>; else goto <D.28833>;
  <D.28832>:
  iftmp.341 = type->data.klass;
  goto <D.28834>;
  <D.28833>:
  iftmp.341 = mono_defaults.uint32_class;
  <D.28834>:
  D.28793 = iftmp.341;
  return D.28793;
  <D.20540>:
  D.28795 = type->data.klass;
  if (D.28795 != 0B) goto <D.28836>; else goto <D.28837>;
  <D.28836>:
  iftmp.342 = type->data.klass;
  goto <D.28838>;
  <D.28837>:
  iftmp.342 = mono_defaults.int_class;
  <D.28838>:
  D.28793 = iftmp.342;
  return D.28793;
  <D.20541>:
  D.28795 = type->data.klass;
  if (D.28795 != 0B) goto <D.28840>; else goto <D.28841>;
  <D.28840>:
  iftmp.343 = type->data.klass;
  goto <D.28842>;
  <D.28841>:
  iftmp.343 = mono_defaults.uint_class;
  <D.28842>:
  D.28793 = iftmp.343;
  return D.28793;
  <D.20542>:
  D.28795 = type->data.klass;
  if (D.28795 != 0B) goto <D.28844>; else goto <D.28845>;
  <D.28844>:
  iftmp.344 = type->data.klass;
  goto <D.28846>;
  <D.28845>:
  iftmp.344 = mono_defaults.int64_class;
  <D.28846>:
  D.28793 = iftmp.344;
  return D.28793;
  <D.20543>:
  D.28795 = type->data.klass;
  if (D.28795 != 0B) goto <D.28848>; else goto <D.28849>;
  <D.28848>:
  iftmp.345 = type->data.klass;
  goto <D.28850>;
  <D.28849>:
  iftmp.345 = mono_defaults.uint64_class;
  <D.28850>:
  D.28793 = iftmp.345;
  return D.28793;
  <D.20544>:
  D.28795 = type->data.klass;
  if (D.28795 != 0B) goto <D.28852>; else goto <D.28853>;
  <D.28852>:
  iftmp.346 = type->data.klass;
  goto <D.28854>;
  <D.28853>:
  iftmp.346 = mono_defaults.single_class;
  <D.28854>:
  D.28793 = iftmp.346;
  return D.28793;
  <D.20545>:
  D.28795 = type->data.klass;
  if (D.28795 != 0B) goto <D.28856>; else goto <D.28857>;
  <D.28856>:
  iftmp.347 = type->data.klass;
  goto <D.28858>;
  <D.28857>:
  iftmp.347 = mono_defaults.double_class;
  <D.28858>:
  D.28793 = iftmp.347;
  return D.28793;
  <D.20546>:
  D.28795 = type->data.klass;
  if (D.28795 != 0B) goto <D.28860>; else goto <D.28861>;
  <D.28860>:
  iftmp.348 = type->data.klass;
  goto <D.28862>;
  <D.28861>:
  iftmp.348 = mono_defaults.string_class;
  <D.28862>:
  D.28793 = iftmp.348;
  return D.28793;
  <D.20547>:
  D.28795 = type->data.klass;
  if (D.28795 != 0B) goto <D.28864>; else goto <D.28865>;
  <D.28864>:
  iftmp.349 = type->data.klass;
  goto <D.28866>;
  <D.28865>:
  iftmp.349 = mono_defaults.typed_reference_class;
  <D.28866>:
  D.28793 = iftmp.349;
  return D.28793;
  <D.20548>:
  D.28867 = type->data.array;
  D.28868 = D.28867->rank;
  D.28869 = (unsigned int) D.28868;
  D.28867 = type->data.array;
  D.28870 = D.28867->eklass;
  D.28793 = mono_bounded_array_class_get (D.28870, D.28869, 1);
  return D.28793;
  <D.20549>:
  D.28871 = type->data.type;
  D.28793 = mono_ptr_class_get (D.28871);
  return D.28793;
  <D.20550>:
  D.28872 = type->data.method;
  D.28793 = mono_fnptr_class_get (D.28872);
  return D.28793;
  <D.20551>:
  D.28795 = type->data.klass;
  D.28793 = mono_array_class_get (D.28795, 1);
  return D.28793;
  <D.20552>:
  <D.20553>:
  D.28793 = type->data.klass;
  return D.28793;
  <D.20554>:
  D.28873 = type->data.generic_class;
  D.28793 = mono_generic_class_get_class (D.28873);
  return D.28793;
  <D.20555>:
  D.28874 = type->data.generic_param;
  D.28793 = mono_class_from_generic_parameter (D.28874, 0B, 0);
  return D.28793;
  <D.20556>:
  D.28874 = type->data.generic_param;
  D.28793 = mono_class_from_generic_parameter (D.28874, 0B, 1);
  return D.28793;
  <D.20557>:
  D.28791 = type->type;
  D.28792 = (int) D.28791;
  monoeg_g_log (0B, 16, "mono_class_from_mono_type: implement me 0x%02x\n", D.28792);
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "class.c", 6305);
  D.28793 = 0B;
  return D.28793;
}


mono_fnptr_class_get (struct MonoMethodSignature * sig)
{
  struct GHashTable * ptr_hash.350;
  struct GHashTable * ptr_hash.351;
  struct MonoClass * D.28882;
  struct MonoImage * D.28883;
  struct MonoClass * D.28884;
  unsigned char D.28885;
  struct MonoMethodSignature * D.28886;
  struct MonoClass * result;
  static struct GHashTable * ptr_hash = 0B;

  mono_loader_lock ();
  ptr_hash.350 = ptr_hash;
  if (ptr_hash.350 == 0B) goto <D.28877>; else goto <D.28878>;
  <D.28877>:
  ptr_hash.351 = monoeg_g_hash_table_new (mono_aligned_addr_hash, 0B);
  ptr_hash = ptr_hash.351;
  <D.28878>:
  ptr_hash.350 = ptr_hash;
  result = monoeg_g_hash_table_lookup (ptr_hash.350, sig);
  if (result != 0B) goto <D.28880>; else goto <D.28881>;
  <D.28880>:
  mono_loader_unlock ();
  D.28882 = result;
  return D.28882;
  <D.28881>:
  result = monoeg_malloc0 (164);
  result->parent = 0B;
  result->name_space = "System";
  result->name = "MonoFNPtrFakeClass";
  mono_profiler_class_event (result, 0);
  D.28883 = mono_defaults.corlib;
  result->image = D.28883;
  result->inited = 1;
  result->flags = 0;
  result->instance_size = 4;
  result->element_class = result;
  D.28884 = result->element_class;
  result->cast_class = D.28884;
  result->blittable = 1;
  result->byval_arg.type = 27;
  D.28885 = result->byval_arg.type;
  result->this_arg.type = D.28885;
  result->byval_arg.data.method = sig;
  D.28886 = result->byval_arg.data.method;
  result->this_arg.data.method = D.28886;
  result->this_arg.byref = 1;
  result->blittable = 1;
  mono_class_setup_supertypes (result);
  ptr_hash.350 = ptr_hash;
  monoeg_g_hash_table_insert_replace (ptr_hash.350, sig, result, 0);
  mono_loader_unlock ();
  mono_profiler_class_loaded (result, 0);
  D.28882 = result;
  return D.28882;
}


mono_bounded_array_class_get (struct MonoClass * eclass, guint32 rank, gboolean bounded)
{
  _Bool D.28888;
  long int D.28889;
  long int D.28890;
  _Bool D.28895;
  _Bool D.28896;
  _Bool D.28897;
  union mono_mutex_t * D.28900;
  _Bool D.28903;
  long int D.28904;
  long int D.28905;
  struct GHashTable * D.28908;
  struct GHashTable * D.28911;
  _Bool D.28914;
  long int D.28915;
  long int D.28916;
  struct MonoClass * D.28921;
  struct GHashTable * D.28923;
  struct GHashTable * D.28926;
  unsigned char D.28929;
  unsigned int D.28930;
  unsigned char D.28933;
  int D.28934;
  int iftmp.352;
  _Bool D.28936;
  _Bool D.28937;
  _Bool D.28938;
  struct MonoAssembly * D.28946;
  unsigned char D.28948;
  const char * D.28950;
  int D.20604;
  int iftmp.353;
  int D.20603;
  const char[9] * D.28955;
  unsigned char D.28956;
  int D.28957;
  unsigned char D.28958;
  int D.28959;
  _Bool D.28960;
  _Bool D.28961;
  _Bool D.28962;
  const unsigned char * D.28965;
  unsigned char D.28966;
  int D.28967;
  const unsigned char * D.28968;
  unsigned char D.28969;
  int D.28970;
  _Bool D.28971;
  _Bool D.28972;
  const unsigned char * D.28975;
  unsigned char D.28976;
  int D.28977;
  const unsigned char * D.28978;
  unsigned char D.28979;
  int D.28980;
  _Bool D.28981;
  _Bool D.28982;
  const unsigned char * D.28985;
  unsigned char D.28986;
  int D.28987;
  const unsigned char * D.28988;
  unsigned char D.28989;
  int D.28990;
  unsigned char D.28993;
  unsigned char D.28994;
  const char * D.28997;
  const char * D.28998;
  unsigned int D.28999;
  unsigned int nsize.354;
  unsigned int D.29001;
  unsigned int D.29002;
  unsigned int nsize.355;
  sizetype nsize.356;
  char * D.29005;
  unsigned int D.29008;
  sizetype D.29009;
  char * D.29010;
  char * D.29013;
  unsigned int bounded.357;
  unsigned int D.29015;
  char * D.29016;
  sizetype D.29017;
  char * D.29018;
  char * D.29019;
  unsigned int classes_size.358;
  unsigned int classes_size.359;
  struct MonoClass * D.29022;
  int D.29023;
  unsigned char D.29024;
  _Bool D.29025;
  _Bool D.29026;
  _Bool D.29027;
  unsigned char D.29033;
  unsigned char D.29034;
  struct MonoType * D.29036;
  unsigned int D.29040;
  unsigned char D.29042;
  int iftmp.360;
  _Bool D.29048;
  long int D.29049;
  long int D.29050;
  int D.29053;
  struct MonoGenericClass * D.29054;
  unsigned char D.29057;
  unsigned char D.29060;
  int iftmp.361;
  struct MonoType * D.29067;
  int D.29068;
  unsigned char D.29070;
  unsigned char D.29071;
  unsigned char D.29072;
  <unnamed-unsigned:1> D.29073;
  unsigned char D.29074;
  struct MonoClass * D.29077;
  struct MonoClass * D.29079;
  unsigned char D.29080;
  int D.29081;
  struct MonoClass * D.29082;
  struct MonoClass * D.29083;
  struct MonoClass * D.29084;
  struct MonoClass * D.29085;
  unsigned char D.29089;
  struct MonoGenericContainer * D.29093;
  _Bool D.29098;
  long int D.29099;
  long int D.29100;
  _Bool D.29108;
  long int D.29109;
  long int D.29110;
  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.28888 = rank > 255;
  D.28889 = (long int) D.28888;
  D.28890 = __builtin_expect (D.28889, 0);
  if (D.28890 != 0) goto <D.28891>; else goto <D.28892>;
  <D.28891>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "class.c", 6386, "rank <= 255");
  <D.28892>:
  if (rank > 1) goto <D.28893>; else goto <D.28894>;
  <D.28893>:
  bounded = 0;
  <D.28894>:
  image = eclass->image;
  D.28895 = rank == 1;
  D.28896 = bounded == 0;
  D.28897 = D.28895 & D.28896;
  if (D.28897 != 0) goto <D.28898>; else goto <D.28899>;
  <D.28898>:
  {
    int ret;

    D.28900 = &image->szarray_cache_lock.mutex;
    ret = pthread_mutex_lock (D.28900);
    if (ret != 0) goto <D.28901>; else goto <D.28902>;
    <D.28901>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
    <D.28902>:
    D.28903 = ret != 0;
    D.28904 = (long int) D.28903;
    D.28905 = __builtin_expect (D.28904, 0);
    if (D.28905 != 0) goto <D.28906>; else goto <D.28907>;
    <D.28906>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "class.c", 6400, "ret == 0");
    <D.28907>:
  }
  D.28908 = image->szarray_cache;
  if (D.28908 == 0B) goto <D.28909>; else goto <D.28910>;
  <D.28909>:
  D.28911 = monoeg_g_hash_table_new (mono_aligned_addr_hash, 0B);
  image->szarray_cache = D.28911;
  <D.28910>:
  D.28908 = image->szarray_cache;
  class = monoeg_g_hash_table_lookup (D.28908, eclass);
  {
    int ret;

    D.28900 = &image->szarray_cache_lock.mutex;
    ret = pthread_mutex_unlock (D.28900);
    if (ret != 0) goto <D.28912>; else goto <D.28913>;
    <D.28912>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.28913>:
    D.28914 = ret != 0;
    D.28915 = (long int) D.28914;
    D.28916 = __builtin_expect (D.28915, 0);
    if (D.28916 != 0) goto <D.28917>; else goto <D.28918>;
    <D.28917>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "class.c", 6404, "ret == 0");
    <D.28918>:
  }
  if (class != 0B) goto <D.28919>; else goto <D.28920>;
  <D.28919>:
  D.28921 = class;
  return D.28921;
  <D.28920>:
  mono_loader_lock ();
  goto <D.28922>;
  <D.28899>:
  mono_loader_lock ();
  D.28923 = image->array_cache;
  if (D.28923 == 0B) goto <D.28924>; else goto <D.28925>;
  <D.28924>:
  D.28926 = monoeg_g_hash_table_new (mono_aligned_addr_hash, 0B);
  image->array_cache = D.28926;
  <D.28925>:
  D.28923 = image->array_cache;
  list = monoeg_g_hash_table_lookup (D.28923, eclass);
  rootlist = list;
  if (rootlist != 0B) goto <D.28927>; else goto <D.28928>;
  <D.28927>:
  goto <D.20594>;
  <D.20593>:
  class = list->data;
  D.28929 = class->rank;
  D.28930 = (unsigned int) D.28929;
  if (D.28930 == rank) goto <D.28931>; else goto <D.28932>;
  <D.28931>:
  D.28933 = class->byval_arg.type;
  D.28934 = (int) D.28933;
  D.28936 = rank > 1;
  D.28937 = bounded != 0;
  D.28938 = D.28936 | D.28937;
  if (D.28938 != 0) goto <D.28939>; else goto <D.28940>;
  <D.28939>:
  iftmp.352 = 20;
  goto <D.28941>;
  <D.28940>:
  iftmp.352 = 29;
  <D.28941>:
  if (D.28934 == iftmp.352) goto <D.28942>; else goto <D.28943>;
  <D.28942>:
  mono_loader_unlock ();
  D.28921 = class;
  return D.28921;
  <D.28943>:
  <D.28932>:
  list = list->next;
  <D.20594>:
  if (list != 0B) goto <D.20593>; else goto <D.20595>;
  <D.20595>:
  <D.28928>:
  <D.28922>:
  D.28946 = image->assembly;
  if (D.28946 != 0B) goto <D.28947>; else goto <D.28944>;
  <D.28947>:
  D.28946 = image->assembly;
  D.28948 = D.28946->dynamic;
  if (D.28948 != 0) goto <D.28949>; else goto <D.28944>;
  <D.28949>:
  D.28950 = image->assembly_name;
  if (D.28950 != 0B) goto <D.28951>; else goto <D.28944>;
  <D.28951>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = image->assembly_name;
      D.28955 = "mscorlib";
      D.28956 = MEM[(const unsigned char *)D.28955];
      D.28957 = (int) D.28956;
      D.28958 = *__s2;
      D.28959 = (int) D.28958;
      __result = D.28957 - D.28959;
      {
        D.28960 = __s2_len != 0;
        D.28961 = __result == 0;
        D.28962 = D.28960 & D.28961;
        if (D.28962 != 0) goto <D.28963>; else goto <D.28964>;
        <D.28963>:
        D.28965 = &MEM[(void *)"mscorlib" + 1B];
        D.28966 = *D.28965;
        D.28967 = (int) D.28966;
        D.28968 = __s2 + 1;
        D.28969 = *D.28968;
        D.28970 = (int) D.28969;
        __result = D.28967 - D.28970;
        D.28971 = __s2_len > 1;
        D.28961 = __result == 0;
        D.28972 = D.28971 & D.28961;
        if (D.28972 != 0) goto <D.28973>; else goto <D.28974>;
        <D.28973>:
        D.28975 = &MEM[(void *)"mscorlib" + 2B];
        D.28976 = *D.28975;
        D.28977 = (int) D.28976;
        D.28978 = __s2 + 2;
        D.28979 = *D.28978;
        D.28980 = (int) D.28979;
        __result = D.28977 - D.28980;
        D.28981 = __s2_len > 2;
        D.28961 = __result == 0;
        D.28982 = D.28981 & D.28961;
        if (D.28982 != 0) goto <D.28983>; else goto <D.28984>;
        <D.28983>:
        D.28985 = &MEM[(void *)"mscorlib" + 3B];
        D.28986 = *D.28985;
        D.28987 = (int) D.28986;
        D.28988 = __s2 + 3;
        D.28989 = *D.28988;
        D.28990 = (int) D.28989;
        __result = D.28987 - D.28990;
        <D.28984>:
        <D.28974>:
        <D.28964>:
      }
      D.20603 = __result;
    }
    iftmp.353 = -D.20603;
    goto <D.28991>;
    <D.28954>:
    D.28950 = image->assembly_name;
    iftmp.353 = __builtin_strcmp (D.28950, "mscorlib");
    <D.28991>:
    D.20604 = iftmp.353;
  }
  if (D.20604 == 0) goto <D.28992>; else goto <D.28944>;
  <D.28992>:
  parent = mono_class_from_name (image, "System", "Array");
  corlib_type = 1;
  goto <D.28945>;
  <D.28944>:
  parent = mono_defaults.array_class;
  D.28993 = BIT_FIELD_REF <*parent, 8, 160>;
  D.28994 = D.28993 & 1;
  if (D.28994 == 0) goto <D.28995>; else goto <D.28996>;
  <D.28995>:
  mono_class_init (parent);
  <D.28996>:
  <D.28945>:
  class = mono_image_alloc0 (image, 164);
  class->image = image;
  D.28997 = eclass->name_space;
  class->name_space = D.28997;
  D.28998 = eclass->name;
  D.28999 = strlen (D.28998);
  nsize = (int) D.28999;
  nsize.354 = (unsigned int) nsize;
  D.29001 = nsize.354 + rank;
  D.29002 = D.29001 + 3;
  name = monoeg_malloc (D.29002);
  nsize.355 = (unsigned int) nsize;
  D.28998 = eclass->name;
  memcpy (name, D.28998, nsize.355);
  nsize.356 = (sizetype) nsize;
  D.29005 = name + nsize.356;
  *D.29005 = 91;
  if (rank > 1) goto <D.29006>; else goto <D.29007>;
  <D.29006>:
  D.29008 = rank + 4294967295;
  nsize.356 = (sizetype) nsize;
  D.29009 = nsize.356 + 1;
  D.29010 = name + D.29009;
  memset (D.29010, 44, D.29008);
  <D.29007>:
  if (bounded != 0) goto <D.29011>; else goto <D.29012>;
  <D.29011>:
  nsize.354 = (unsigned int) nsize;
  D.29001 = nsize.354 + rank;
  D.29013 = name + D.29001;
  *D.29013 = 42;
  <D.29012>:
  nsize.354 = (unsigned int) nsize;
  D.29001 = nsize.354 + rank;
  bounded.357 = (unsigned int) bounded;
  D.29015 = D.29001 + bounded.357;
  D.29016 = name + D.29015;
  *D.29016 = 93;
  nsize.354 = (unsigned int) nsize;
  D.29001 = nsize.354 + rank;
  bounded.357 = (unsigned int) bounded;
  D.29015 = D.29001 + bounded.357;
  D.29017 = D.29015 + 1;
  D.29018 = name + D.29017;
  *D.29018 = 0;
  D.29019 = mono_image_strdup (image, name);
  class->name = D.29019;
  monoeg_g_free (name);
  mono_profiler_class_event (class, 0);
  classes_size.358 = classes_size;
  classes_size.359 = classes_size.358 + 164;
  classes_size = classes_size.359;
  class->type_token = 0;
  class->flags = 8449;
  class->parent = parent;
  D.29022 = class->parent;
  D.29023 = mono_class_instance_size (D.29022);
  class->instance_size = D.29023;
  D.29024 = eclass->byval_arg.type;
  D.29025 = D.29024 == 22;
  D.29026 = D.29024 == 1;
  D.29027 = D.29025 | D.29026;
  if (D.29027 != 0) goto <D.29028>; else goto <D.29029>;
  <D.29028>:
  mono_class_set_failure (class, 7, 0B);
  goto <D.29030>;
  <D.29029>:
  D.29033 = BIT_FIELD_REF <*eclass, 8, 160>;
  D.29034 = D.29033 & 16;
  if (D.29034 != 0) goto <D.29035>; else goto <D.29031>;
  <D.29035>:
  D.29036 = mono_class_enum_basetype (eclass);
  if (D.29036 == 0B) goto <D.29037>; else goto <D.29031>;
  <D.29037>:
  D.29040 = eclass->ref_info_handle;
  if (D.29040 == 0) goto <D.29038>; else goto <D.29041>;
  <D.29041>:
  D.29033 = BIT_FIELD_REF <*eclass, 8, 160>;
  D.29042 = D.29033 & 128;
  if (D.29042 != 0) goto <D.29038>; else goto <D.29039>;
  <D.29038>:
  monoeg_g_log (0B, 16, "Only incomplete TypeBuilder objects are allowed to be an enum without base_type");
  D.29040 = eclass->ref_info_handle;
  if (D.29040 == 0) goto <D.29044>; else goto <D.29047>;
  <D.29047>:
  D.29033 = BIT_FIELD_REF <*eclass, 8, 160>;
  D.29042 = D.29033 & 128;
  if (D.29042 != 0) goto <D.29044>; else goto <D.29045>;
  <D.29044>:
  iftmp.360 = 1;
  goto <D.29046>;
  <D.29045>:
  iftmp.360 = 0;
  <D.29046>:
  D.29048 = iftmp.360 != 0;
  D.29049 = (long int) D.29048;
  D.29050 = __builtin_expect (D.29049, 0);
  if (D.29050 != 0) goto <D.29051>; else goto <D.29052>;
  <D.29051>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "class.c", 6469, "eclass->ref_info_handle && !eclass->wastypebuilder");
  <D.29052>:
  <D.29039>:
  class->sizes.element_size = -1;
  goto <D.29032>;
  <D.29031>:
  D.29053 = mono_class_array_element_size (eclass);
  class->sizes.element_size = D.29053;
  <D.29032>:
  <D.29030>:
  mono_class_setup_supertypes (class);
  D.29054 = eclass->generic_class;
  if (D.29054 != 0B) goto <D.29055>; else goto <D.29056>;
  <D.29055>:
  mono_class_init (eclass);
  <D.29056>:
  D.29033 = BIT_FIELD_REF <*eclass, 8, 160>;
  D.29057 = D.29033 & 4;
  if (D.29057 == 0) goto <D.29058>; else goto <D.29059>;
  <D.29058>:
  mono_class_setup_fields (eclass);
  <D.29059>:
  D.29060 = eclass->exception_type;
  if (D.29060 != 0) goto <D.29061>; else goto <D.29062>;
  <D.29061>:
  mono_class_set_failure (class, 7, 0B);
  <D.29062>:
  D.29067 = &eclass->byval_arg;
  D.29068 = mono_type_is_reference (D.29067);
  if (D.29068 != 0) goto <D.29064>; else goto <D.29069>;
  <D.29069>:
  D.29070 = BIT_FIELD_REF <*eclass, 8, 184>;
  D.29071 = D.29070 & 8;
  if (D.29071 != 0) goto <D.29064>; else goto <D.29065>;
  <D.29064>:
  iftmp.361 = 1;
  goto <D.29066>;
  <D.29065>:
  iftmp.361 = 0;
  <D.29066>:
  D.29072 = (unsigned char) iftmp.361;
  D.29073 = (<unnamed-unsigned:1>) D.29072;
  class->has_references = D.29073;
  D.29074 = (unsigned char) rank;
  class->rank = D.29074;
  D.29033 = BIT_FIELD_REF <*eclass, 8, 160>;
  D.29034 = D.29033 & 16;
  if (D.29034 != 0) goto <D.29075>; else goto <D.29076>;
  <D.29075>:
  D.29077 = eclass->element_class;
  class->cast_class = D.29077;
  goto <D.29078>;
  <D.29076>:
  class->cast_class = eclass;
  <D.29078>:
  D.29079 = class->cast_class;
  D.29080 = D.29079->byval_arg.type;
  D.29081 = (int) D.29080;
  switch (D.29081) <default: <D.29086>, case 4: <D.20605>, case 7: <D.20607>, case 9: <D.20608>, case 11: <D.20611>, case 24: <D.20609>, case 25: <D.20610>>
  <D.20605>:
  D.29082 = mono_defaults.byte_class;
  class->cast_class = D.29082;
  goto <D.20606>;
  <D.20607>:
  D.29083 = mono_defaults.int16_class;
  class->cast_class = D.29083;
  goto <D.20606>;
  <D.20608>:
  <D.20609>:
  <D.20610>:
  D.29084 = mono_defaults.int32_class;
  class->cast_class = D.29084;
  goto <D.20606>;
  <D.20611>:
  D.29085 = mono_defaults.int64_class;
  class->cast_class = D.29085;
  goto <D.20606>;
  <D.29086>:
  <D.20606>:
  class->element_class = eclass;
  D.28936 = rank > 1;
  D.28937 = bounded != 0;
  D.28938 = D.28936 | D.28937;
  if (D.28938 != 0) goto <D.29087>; else goto <D.29088>;
  <D.29087>:
  {
    struct MonoArrayType * at;

    at = mono_image_alloc0 (image, 16);
    class->byval_arg.type = 20;
    class->byval_arg.data.array = at;
    at->eklass = eclass;
    D.29089 = (unsigned char) rank;
    at->rank = D.29089;
  }
  goto <D.29090>;
  <D.29088>:
  class->byval_arg.type = 29;
  class->byval_arg.data.klass = eclass;
  <D.29090>:
  class->this_arg = class->byval_arg;
  class->this_arg.byref = 1;
  if (corlib_type != 0) goto <D.29091>; else goto <D.29092>;
  <D.29091>:
  class->inited = 1;
  <D.29092>:
  D.29093 = eclass->generic_container;
  class->generic_container = D.29093;
  D.28895 = rank == 1;
  D.28896 = bounded == 0;
  D.28897 = D.28895 & D.28896;
  if (D.28897 != 0) goto <D.29094>; else goto <D.29095>;
  <D.29094>:
  {
    struct MonoClass * prev_class;

    {
      int ret;

      D.28900 = &image->szarray_cache_lock.mutex;
      ret = pthread_mutex_lock (D.28900);
      if (ret != 0) goto <D.29096>; else goto <D.29097>;
      <D.29096>:
      monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
      <D.29097>:
      D.29098 = ret != 0;
      D.29099 = (long int) D.29098;
      D.29100 = __builtin_expect (D.29099, 0);
      if (D.29100 != 0) goto <D.29101>; else goto <D.29102>;
      <D.29101>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "class.c", 6541, "ret == 0");
      <D.29102>:
    }
    D.28908 = image->szarray_cache;
    prev_class = monoeg_g_hash_table_lookup (D.28908, eclass);
    if (prev_class != 0B) goto <D.29103>; else goto <D.29104>;
    <D.29103>:
    class = prev_class;
    goto <D.29105>;
    <D.29104>:
    D.28908 = image->szarray_cache;
    monoeg_g_hash_table_insert_replace (D.28908, eclass, class, 0);
    <D.29105>:
    {
      int ret;

      D.28900 = &image->szarray_cache_lock.mutex;
      ret = pthread_mutex_unlock (D.28900);
      if (ret != 0) goto <D.29106>; else goto <D.29107>;
      <D.29106>:
      monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
      <D.29107>:
      D.29108 = ret != 0;
      D.29109 = (long int) D.29108;
      D.29110 = __builtin_expect (D.29109, 0);
      if (D.29110 != 0) goto <D.29111>; else goto <D.29112>;
      <D.29111>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "class.c", 6548, "ret == 0");
      <D.29112>:
    }
  }
  goto <D.29113>;
  <D.29095>:
  list = monoeg_g_slist_append (rootlist, class);
  D.28923 = image->array_cache;
  monoeg_g_hash_table_insert_replace (D.28923, eclass, list, 0);
  <D.29113>:
  mono_loader_unlock ();
  mono_profiler_class_loaded (class, 0);
  D.28921 = class;
  return D.28921;
}


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

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


mono_class_instance_size (struct MonoClass * klass)
{
  unsigned char D.29117;
  unsigned char D.29118;
  int32_t D.29121;

  D.29117 = BIT_FIELD_REF <*klass, 8, 160>;
  D.29118 = D.29117 & 4;
  if (D.29118 == 0) goto <D.29119>; else goto <D.29120>;
  <D.29119>:
  mono_class_init (klass);
  <D.29120>:
  D.29121 = klass->instance_size;
  return D.29121;
}


mono_class_min_align (struct MonoClass * klass)
{
  unsigned char D.29123;
  unsigned char D.29124;
  int32_t D.29127;
  unsigned char D.29128;

  D.29123 = BIT_FIELD_REF <*klass, 8, 160>;
  D.29124 = D.29123 & 4;
  if (D.29124 == 0) goto <D.29125>; else goto <D.29126>;
  <D.29125>:
  mono_class_init (klass);
  <D.29126>:
  D.29128 = klass->min_align;
  D.29127 = (int32_t) D.29128;
  return D.29127;
}


mono_class_value_size (struct MonoClass * klass, guint32 * align)
{
  int D.29130;
  unsigned int D.29131;
  unsigned int D.29132;
  unsigned char D.29135;
  unsigned int D.29136;
  int32_t D.29137;
  gint32 size;

  D.29130 = mono_class_instance_size (klass);
  D.29131 = (unsigned int) D.29130;
  D.29132 = D.29131 + 4294967288;
  size = (gint32) D.29132;
  if (align != 0B) goto <D.29133>; else goto <D.29134>;
  <D.29133>:
  D.29135 = klass->min_align;
  D.29136 = (unsigned int) D.29135;
  *align = D.29136;
  <D.29134>:
  D.29137 = size;
  return D.29137;
}


mono_class_data_size (struct MonoClass * klass)
{
  unsigned char D.29139;
  unsigned char D.29140;
  unsigned char D.29143;
  unsigned char D.29144;
  unsigned char D.29147;
  int32_t D.29150;

  D.29139 = BIT_FIELD_REF <*klass, 8, 160>;
  D.29140 = D.29139 & 1;
  if (D.29140 == 0) goto <D.29141>; else goto <D.29142>;
  <D.29141>:
  mono_class_init (klass);
  <D.29142>:
  D.29143 = BIT_FIELD_REF <*klass, 8, 192>;
  D.29144 = D.29143 & 32;
  if (D.29144 == 0) goto <D.29145>; else goto <D.29146>;
  <D.29145>:
  mono_class_setup_fields_locking (klass);
  <D.29146>:
  D.29147 = klass->rank;
  if (D.29147 != 0) goto <D.29148>; else goto <D.29149>;
  <D.29148>:
  D.29150 = 0;
  return D.29150;
  <D.29149>:
  D.29150 = klass->sizes.class_size;
  return D.29150;
}


mono_class_get_field (struct MonoClass * class, guint32 field_token)
{
  int field_token.362;
  unsigned int D.29153;
  _Bool D.29154;
  long int D.29155;
  long int D.29156;
  struct MonoClassField * D.29159;
  int D.29160;
  int idx;

  field_token.362 = (int) field_token;
  idx = field_token.362 & 16777215;
  D.29153 = field_token & 4278190080;
  D.29154 = D.29153 != 67108864;
  D.29155 = (long int) D.29154;
  D.29156 = __builtin_expect (D.29155, 0);
  if (D.29156 != 0) goto <D.29157>; else goto <D.29158>;
  <D.29157>:
  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.29158>:
  D.29160 = idx + -1;
  D.29159 = mono_class_get_field_idx (class, D.29160);
  return D.29159;
}


mono_class_get_field_idx (struct MonoClass * class, int idx)
{
  unsigned char D.29162;
  struct MonoClassField * D.29165;
  struct MonoImage * D.29166;
  unsigned char D.29167;
  unsigned char D.29168;
  struct MonoTableInfo * D.29171;
  unsigned int D.29172;
  struct MonoClassField * D.29173;
  unsigned int i.363;
  unsigned int D.29175;
  struct MonoClassField * D.29176;
  const char * D.29177;
  unsigned int i.364;
  unsigned int D.29181;
  unsigned int idx.365;
  unsigned int D.29185;
  unsigned int D.29188;
  unsigned int D.29191;
  unsigned int D.29192;

  mono_class_setup_fields_locking (class);
  D.29162 = class->exception_type;
  if (D.29162 != 0) goto <D.29163>; else goto <D.29164>;
  <D.29163>:
  D.29165 = 0B;
  return D.29165;
  <D.29164>:
  goto <D.20644>;
  <D.20643>:
  D.29166 = class->image;
  D.29167 = BIT_FIELD_REF <*D.29166, 8, 128>;
  D.29168 = D.29167 & 32;
  if (D.29168 != 0) goto <D.29169>; else goto <D.29170>;
  <D.29169>:
  {
    const char * name;
    int i;

    D.29166 = class->image;
    D.29171 = &D.29166->tables[4];
    D.29172 = mono_metadata_decode_row_col (D.29171, idx, 1);
    D.29166 = class->image;
    name = mono_metadata_string_heap (D.29166, D.29172);
    i = 0;
    goto <D.20641>;
    <D.20640>:
    D.29173 = class->fields;
    i.363 = (unsigned int) i;
    D.29175 = i.363 * 16;
    D.29176 = D.29173 + D.29175;
    D.29177 = mono_field_get_name (D.29176);
    if (D.29177 == name) goto <D.29178>; else goto <D.29179>;
    <D.29178>:
    D.29173 = class->fields;
    i.363 = (unsigned int) i;
    D.29175 = i.363 * 16;
    D.29165 = D.29173 + D.29175;
    return D.29165;
    <D.29179>:
    i = i + 1;
    <D.20641>:
    i.364 = (unsigned int) i;
    D.29181 = class->field.count;
    if (i.364 < D.29181) goto <D.20640>; else goto <D.20642>;
    <D.20642>:
    monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "class.c", 6680);
  }
  <D.29170>:
  D.29181 = class->field.count;
  if (D.29181 != 0) goto <D.29182>; else goto <D.29183>;
  <D.29182>:
  idx.365 = (unsigned int) idx;
  D.29185 = class->field.first;
  if (idx.365 >= D.29185) goto <D.29186>; else goto <D.29187>;
  <D.29186>:
  idx.365 = (unsigned int) idx;
  D.29185 = class->field.first;
  D.29181 = class->field.count;
  D.29188 = D.29185 + D.29181;
  if (idx.365 < D.29188) goto <D.29189>; else goto <D.29190>;
  <D.29189>:
  D.29173 = class->fields;
  idx.365 = (unsigned int) idx;
  D.29185 = class->field.first;
  D.29191 = idx.365 - D.29185;
  D.29192 = D.29191 * 16;
  D.29165 = D.29173 + D.29192;
  return D.29165;
  <D.29190>:
  <D.29187>:
  <D.29183>:
  class = class->parent;
  <D.20644>:
  if (class != 0B) goto <D.20643>; else goto <D.20645>;
  <D.20645>:
  D.29165 = 0B;
  return D.29165;
}


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

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


mono_class_get_field_from_name_full (struct MonoClass * klass, const char * name, struct MonoType * type)
{
  unsigned char D.29196;
  struct MonoClassField * D.29199;
  struct MonoClassField * D.29200;
  unsigned int i.366;
  unsigned int D.29202;
  int D.20670;
  const char * D.29203;
  struct MonoClassField * D.29208;
  int D.29209;
  unsigned int i.367;
  unsigned int D.29213;
  int i;

  mono_class_setup_fields_locking (klass);
  D.29196 = klass->exception_type;
  if (D.29196 != 0) goto <D.29197>; else goto <D.29198>;
  <D.29197>:
  D.29199 = 0B;
  return D.29199;
  <D.29198>:
  goto <D.20677>;
  <D.20676>:
  i = 0;
  goto <D.20674>;
  <D.20673>:
  {
    struct MonoClassField * field;

    D.29200 = klass->fields;
    i.366 = (unsigned int) i;
    D.29202 = i.366 * 16;
    field = D.29200 + D.29202;
    {
      size_t __s1_len;
      size_t __s2_len;

      D.29203 = mono_field_get_name (field);
      D.20670 = __builtin_strcmp (name, D.29203);
    }
    if (D.20670 != 0) goto <D.29204>; else goto <D.29205>;
    <D.29204>:
    // predicted unlikely by continue predictor.
    goto <D.20671>;
    <D.29205>:
    if (type != 0B) goto <D.29206>; else goto <D.29207>;
    <D.29206>:
    {
      struct MonoType * field_type;

      D.29208 = mono_metadata_get_corresponding_field_from_generic_type_definition (field);
      field_type = D.29208->type;
      D.29209 = mono_metadata_type_equal_full (type, field_type, 1);
      if (D.29209 == 0) goto <D.29210>; else goto <D.29211>;
      <D.29210>:
      // predicted unlikely by continue predictor.
      goto <D.20671>;
      <D.29211>:
    }
    <D.29207>:
    D.29199 = field;
    return D.29199;
  }
  <D.20671>:
  i = i + 1;
  <D.20674>:
  i.367 = (unsigned int) i;
  D.29213 = klass->field.count;
  if (i.367 < D.29213) goto <D.20673>; else goto <D.20675>;
  <D.20675>:
  klass = klass->parent;
  <D.20677>:
  if (klass != 0B) goto <D.20676>; else goto <D.20678>;
  <D.20678>:
  D.29199 = 0B;
  return D.29199;
}


mono_class_get_field_token (struct MonoClassField * field)
{
  struct MonoClassField * D.29215;
  uint32_t D.29218;
  unsigned int i.368;
  unsigned int D.29220;
  struct MonoClassField * D.29221;
  unsigned int D.29224;
  unsigned int i.369;
  unsigned int D.29226;
  unsigned int D.29227;
  struct MonoImage * D.29228;
  unsigned char D.29229;
  unsigned char D.29230;
  unsigned int idx.370;
  unsigned int D.29234;
  int D.29235;
  unsigned int D.29236;
  struct MonoClass * klass;
  int i;

  klass = field->parent;
  mono_class_setup_fields_locking (klass);
  goto <D.20689>;
  <D.20688>:
  D.29215 = klass->fields;
  if (D.29215 == 0B) goto <D.29216>; else goto <D.29217>;
  <D.29216>:
  D.29218 = 0;
  return D.29218;
  <D.29217>:
  i = 0;
  goto <D.20686>;
  <D.20685>:
  D.29215 = klass->fields;
  i.368 = (unsigned int) i;
  D.29220 = i.368 * 16;
  D.29221 = D.29215 + D.29220;
  if (D.29221 == field) goto <D.29222>; else goto <D.29223>;
  <D.29222>:
  {
    int idx;

    D.29224 = klass->field.first;
    i.369 = (unsigned int) i;
    D.29226 = D.29224 + i.369;
    D.29227 = D.29226 + 1;
    idx = (int) D.29227;
    D.29228 = klass->image;
    D.29229 = BIT_FIELD_REF <*D.29228, 8, 128>;
    D.29230 = D.29229 & 32;
    if (D.29230 != 0) goto <D.29231>; else goto <D.29232>;
    <D.29231>:
    idx.370 = (unsigned int) idx;
    D.29228 = klass->image;
    D.29234 = mono_metadata_translate_token_index (D.29228, 4, idx.370);
    idx = (int) D.29234;
    <D.29232>:
    D.29235 = idx | 67108864;
    D.29218 = (uint32_t) D.29235;
    return D.29218;
  }
  <D.29223>:
  i = i + 1;
  <D.20686>:
  i.369 = (unsigned int) i;
  D.29236 = klass->field.count;
  if (i.369 < D.29236) goto <D.20685>; else goto <D.20687>;
  <D.20687>:
  klass = klass->parent;
  <D.20689>:
  if (klass != 0B) goto <D.20688>; else goto <D.20690>;
  <D.20690>:
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "class.c", 6800);
  D.29218 = 0;
  return D.29218;
}


mono_class_get_field_default_value (struct MonoClassField * field, MonoTypeEnum * def_type)
{
  struct MonoType * D.29238;
  short unsigned int D.29239;
  signed short D.29240;
  _Bool D.29241;
  long int D.29242;
  long int D.29243;
  struct MonoClassExt * D.29248;
  struct MonoFieldDefaultValue * D.29250;
  unsigned int D.29253;
  unsigned int D.29254;
  int D.29255;
  void * D.29256;
  unsigned int field_index.371;
  unsigned int D.29258;
  struct MonoFieldDefaultValue * D.29259;
  const char * D.29260;
  unsigned int D.29263;
  struct MonoClass * D.29264;
  struct MonoImage * D.29265;
  const char * D.29268;
  int D.29269;
  int D.29270;
  _Bool D.29271;
  long int D.29272;
  long int D.29273;
  unsigned int D.29276;
  int D.29277;
  struct MonoTableInfo * D.29278;
  unsigned int D.29279;
  unsigned int D.29280;
  const char * D.29281;
  <unnamed type> D.29282;
  guint32 cindex;
  guint32 constant_cols[4];
  int field_index;
  struct MonoClass * klass;

  try
    {
      klass = field->parent;
      D.29238 = field->type;
      D.29239 = D.29238->attrs;
      D.29240 = (signed short) D.29239;
      D.29241 = D.29240 >= 0;
      D.29242 = (long int) D.29241;
      D.29243 = __builtin_expect (D.29242, 0);
      if (D.29243 != 0) goto <D.29244>; else goto <D.29245>;
      <D.29244>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "class.c", 6827, "field->type->attrs & FIELD_ATTRIBUTE_HAS_DEFAULT");
      <D.29245>:
      D.29248 = klass->ext;
      if (D.29248 == 0B) goto <D.29246>; else goto <D.29249>;
      <D.29249>:
      D.29248 = klass->ext;
      D.29250 = D.29248->field_def_values;
      if (D.29250 == 0B) goto <D.29246>; else goto <D.29247>;
      <D.29246>:
      mono_loader_lock ();
      mono_class_alloc_ext (klass);
      D.29248 = klass->ext;
      D.29250 = D.29248->field_def_values;
      if (D.29250 == 0B) goto <D.29251>; else goto <D.29252>;
      <D.29251>:
      D.29248 = klass->ext;
      D.29253 = klass->field.count;
      D.29254 = D.29253 * 8;
      D.29255 = (int) D.29254;
      D.29256 = mono_class_alloc0 (klass, D.29255);
      D.29248->field_def_values = D.29256;
      <D.29252>:
      mono_loader_unlock ();
      <D.29247>:
      field_index = mono_field_get_index (field);
      D.29248 = klass->ext;
      D.29250 = D.29248->field_def_values;
      field_index.371 = (unsigned int) field_index;
      D.29258 = field_index.371 * 8;
      D.29259 = D.29250 + D.29258;
      D.29260 = D.29259->data;
      if (D.29260 == 0B) goto <D.29261>; else goto <D.29262>;
      <D.29261>:
      D.29263 = mono_class_get_field_token (field);
      D.29264 = field->parent;
      D.29265 = D.29264->image;
      cindex = mono_metadata_get_constant_index (D.29265, D.29263, 0);
      if (cindex == 0) goto <D.29266>; else goto <D.29267>;
      <D.29266>:
      D.29268 = 0B;
      return D.29268;
      <D.29267>:
      D.29238 = field->type;
      D.29239 = D.29238->attrs;
      D.29269 = (int) D.29239;
      D.29270 = D.29269 & 256;
      D.29271 = D.29270 != 0;
      D.29272 = (long int) D.29271;
      D.29273 = __builtin_expect (D.29272, 0);
      if (D.29273 != 0) goto <D.29274>; else goto <D.29275>;
      <D.29274>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "class.c", 6844, "!(field->type->attrs & FIELD_ATTRIBUTE_HAS_FIELD_RVA)");
      <D.29275>:
      D.29276 = cindex + 4294967295;
      D.29277 = (int) D.29276;
      D.29264 = field->parent;
      D.29265 = D.29264->image;
      D.29278 = &D.29265->tables[11];
      mono_metadata_decode_row (D.29278, D.29277, &constant_cols, 4);
      D.29248 = klass->ext;
      D.29250 = D.29248->field_def_values;
      field_index.371 = (unsigned int) field_index;
      D.29258 = field_index.371 * 8;
      D.29259 = D.29250 + D.29258;
      D.29279 = constant_cols[0];
      D.29259->def_type = D.29279;
      D.29248 = klass->ext;
      D.29250 = D.29248->field_def_values;
      field_index.371 = (unsigned int) field_index;
      D.29258 = field_index.371 * 8;
      D.29259 = D.29250 + D.29258;
      D.29280 = constant_cols[3];
      D.29264 = field->parent;
      D.29265 = D.29264->image;
      D.29281 = mono_metadata_blob_heap (D.29265, D.29280);
      D.29259->data = D.29281;
      <D.29262>:
      D.29248 = klass->ext;
      D.29250 = D.29248->field_def_values;
      field_index.371 = (unsigned int) field_index;
      D.29258 = field_index.371 * 8;
      D.29259 = D.29250 + D.29258;
      D.29282 = D.29259->def_type;
      *def_type = D.29282;
      D.29248 = klass->ext;
      D.29250 = D.29248->field_def_values;
      field_index.371 = (unsigned int) field_index;
      D.29258 = field_index.371 * 8;
      D.29259 = D.29250 + D.29258;
      D.29268 = D.29259->data;
      return D.29268;
    }
  finally
    {
      constant_cols = {CLOBBER};
    }
}


mono_field_get_index (struct MonoClassField * field)
{
  int field.372;
  struct MonoClass * D.29286;
  struct MonoClassField * D.29287;
  int D.29288;
  int D.29289;
  int iftmp.373;
  unsigned int index.374;
  unsigned int D.29296;
  _Bool D.29297;
  long int D.29298;
  long int D.29299;
  int D.29302;
  int index;

  field.372 = (int) field;
  D.29286 = field->parent;
  D.29287 = D.29286->fields;
  D.29288 = (int) D.29287;
  D.29289 = field.372 - D.29288;
  index = D.29289 /[ex] 16;
  if (index < 0) goto <D.29291>; else goto <D.29294>;
  <D.29294>:
  index.374 = (unsigned int) index;
  D.29286 = field->parent;
  D.29296 = D.29286->field.count;
  if (index.374 >= D.29296) goto <D.29291>; else goto <D.29292>;
  <D.29291>:
  iftmp.373 = 1;
  goto <D.29293>;
  <D.29292>:
  iftmp.373 = 0;
  <D.29293>:
  D.29297 = iftmp.373 != 0;
  D.29298 = (long int) D.29297;
  D.29299 = __builtin_expect (D.29298, 0);
  if (D.29299 != 0) goto <D.29300>; else goto <D.29301>;
  <D.29300>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "class.c", 6809, "index >= 0 && index < field->parent->field.count");
  <D.29301>:
  D.29302 = index;
  return D.29302;
}


mono_class_get_property_default_value (struct MonoProperty * property, MonoTypeEnum * def_type)
{
  unsigned int D.29304;
  unsigned int D.29305;
  _Bool D.29306;
  long int D.29307;
  long int D.29308;
  struct MonoImage * D.29311;
  unsigned char D.29312;
  unsigned char D.29313;
  struct MonoClassExt * D.29316;
  struct MonoFieldDefaultValue * D.29317;
  unsigned int prop_index.375;
  unsigned int D.29321;
  struct MonoFieldDefaultValue * D.29322;
  const char * D.29323;
  <unnamed type> D.29326;
  const char * D.29327;
  unsigned int D.29328;
  unsigned int D.29331;
  int D.29332;
  struct MonoTableInfo * D.29333;
  unsigned int D.29334;
  unsigned int D.29335;
  guint32 cindex;
  guint32 constant_cols[4];
  struct MonoClass * klass;

  try
    {
      klass = property->parent;
      D.29304 = property->attrs;
      D.29305 = D.29304 & 4096;
      D.29306 = D.29305 == 0;
      D.29307 = (long int) D.29306;
      D.29308 = __builtin_expect (D.29307, 0);
      if (D.29308 != 0) goto <D.29309>; else goto <D.29310>;
      <D.29309>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "class.c", 6877, "property->attrs & PROPERTY_ATTRIBUTE_HAS_DEFAULT");
      <D.29310>:
      D.29311 = klass->image;
      D.29312 = BIT_FIELD_REF <*D.29311, 8, 128>;
      D.29313 = D.29312 & 8;
      if (D.29313 != 0) goto <D.29314>; else goto <D.29315>;
      <D.29314>:
      {
        int prop_index;

        prop_index = mono_property_get_index (property);
        D.29316 = klass->ext;
        D.29317 = D.29316->prop_def_values;
        if (D.29317 != 0B) goto <D.29318>; else goto <D.29319>;
        <D.29318>:
        D.29316 = klass->ext;
        D.29317 = D.29316->prop_def_values;
        prop_index.375 = (unsigned int) prop_index;
        D.29321 = prop_index.375 * 8;
        D.29322 = D.29317 + D.29321;
        D.29323 = D.29322->data;
        if (D.29323 != 0B) goto <D.29324>; else goto <D.29325>;
        <D.29324>:
        D.29316 = klass->ext;
        D.29317 = D.29316->prop_def_values;
        prop_index.375 = (unsigned int) prop_index;
        D.29321 = prop_index.375 * 8;
        D.29322 = D.29317 + D.29321;
        D.29326 = D.29322->def_type;
        *def_type = D.29326;
        D.29316 = klass->ext;
        D.29317 = D.29316->prop_def_values;
        prop_index.375 = (unsigned int) prop_index;
        D.29321 = prop_index.375 * 8;
        D.29322 = D.29317 + D.29321;
        D.29327 = D.29322->data;
        return D.29327;
        <D.29325>:
        <D.29319>:
        D.29327 = 0B;
        return D.29327;
      }
      <D.29315>:
      D.29328 = mono_class_get_property_token (property);
      D.29311 = klass->image;
      cindex = mono_metadata_get_constant_index (D.29311, D.29328, 0);
      if (cindex == 0) goto <D.29329>; else goto <D.29330>;
      <D.29329>:
      D.29327 = 0B;
      return D.29327;
      <D.29330>:
      D.29331 = cindex + 4294967295;
      D.29332 = (int) D.29331;
      D.29311 = klass->image;
      D.29333 = &D.29311->tables[11];
      mono_metadata_decode_row (D.29333, D.29332, &constant_cols, 4);
      D.29334 = constant_cols[0];
      *def_type = D.29334;
      D.29335 = constant_cols[3];
      D.29311 = klass->image;
      D.29327 = mono_metadata_blob_heap (D.29311, D.29335);
      return D.29327;
    }
  finally
    {
      constant_cols = {CLOBBER};
    }
}


mono_property_get_index (struct MonoProperty * prop)
{
  int prop.376;
  struct MonoClass * D.29339;
  struct MonoClassExt * D.29340;
  struct MonoProperty * D.29341;
  int D.29342;
  int D.29343;
  int iftmp.377;
  unsigned int index.378;
  unsigned int D.29350;
  _Bool D.29351;
  long int D.29352;
  long int D.29353;
  int D.29356;
  int index;

  prop.376 = (int) prop;
  D.29339 = prop->parent;
  D.29340 = D.29339->ext;
  D.29341 = D.29340->properties;
  D.29342 = (int) D.29341;
  D.29343 = prop.376 - D.29342;
  index = D.29343 /[ex] 20;
  if (index < 0) goto <D.29345>; else goto <D.29348>;
  <D.29348>:
  index.378 = (unsigned int) index;
  D.29339 = prop->parent;
  D.29340 = D.29339->ext;
  D.29350 = D.29340->property.count;
  if (index.378 >= D.29350) goto <D.29345>; else goto <D.29346>;
  <D.29345>:
  iftmp.377 = 1;
  goto <D.29347>;
  <D.29346>:
  iftmp.377 = 0;
  <D.29347>:
  D.29351 = iftmp.377 != 0;
  D.29352 = (long int) D.29351;
  D.29353 = __builtin_expect (D.29352, 0);
  if (D.29353 != 0) goto <D.29354>; else goto <D.29355>;
  <D.29354>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "class.c", 6860, "index >= 0 && index < prop->parent->ext->property.count");
  <D.29355>:
  D.29356 = index;
  return D.29356;
}


mono_class_get_event_token (struct MonoEvent * event)
{
  struct MonoClassExt * D.29358;
  struct MonoEvent * D.29361;
  unsigned int i.379;
  unsigned int D.29363;
  struct MonoEvent * D.29364;
  uint32_t D.29367;
  unsigned int D.29368;
  unsigned int i.380;
  unsigned int D.29370;
  unsigned int D.29371;
  unsigned int D.29372;
  struct MonoClass * klass;
  int i;

  klass = event->parent;
  goto <D.20724>;
  <D.20723>:
  D.29358 = klass->ext;
  if (D.29358 != 0B) goto <D.29359>; else goto <D.29360>;
  <D.29359>:
  i = 0;
  goto <D.20721>;
  <D.20720>:
  D.29358 = klass->ext;
  D.29361 = D.29358->events;
  i.379 = (unsigned int) i;
  D.29363 = i.379 * 28;
  D.29364 = D.29361 + D.29363;
  if (D.29364 == event) goto <D.29365>; else goto <D.29366>;
  <D.29365>:
  D.29358 = klass->ext;
  D.29368 = D.29358->event.first;
  i.380 = (unsigned int) i;
  D.29370 = D.29368 + i.380;
  D.29371 = D.29370 + 1;
  D.29367 = D.29371 | 335544320;
  return D.29367;
  <D.29366>:
  i = i + 1;
  <D.20721>:
  i.380 = (unsigned int) i;
  D.29358 = klass->ext;
  D.29372 = D.29358->event.count;
  if (i.380 < D.29372) goto <D.20720>; else goto <D.20722>;
  <D.20722>:
  <D.29360>:
  klass = klass->parent;
  <D.20724>:
  if (klass != 0B) goto <D.20723>; else goto <D.20725>;
  <D.20725>:
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "class.c", 6917);
  D.29367 = 0;
  return D.29367;
}


mono_class_get_property_from_name (struct MonoClass * klass, const char * name)
{
  int D.20740;
  const char * D.29374;
  struct MonoProperty * D.29377;

  goto <D.20745>;
  <D.20744>:
  {
    struct MonoProperty * p;
    void * iter;

    try
      {
        iter = 0B;
        goto <D.20742>;
        <D.20741>:
        {
          size_t __s1_len;
          size_t __s2_len;

          D.29374 = p->name;
          D.20740 = __builtin_strcmp (name, D.29374);
        }
        if (D.20740 == 0) goto <D.29375>; else goto <D.29376>;
        <D.29375>:
        D.29377 = p;
        return D.29377;
        <D.29376>:
        <D.20742>:
        p = mono_class_get_properties (klass, &iter);
        if (p != 0B) goto <D.20741>; else goto <D.20743>;
        <D.20743>:
        klass = klass->parent;
      }
    finally
      {
        iter = {CLOBBER};
      }
  }
  <D.20745>:
  if (klass != 0B) goto <D.20744>; else goto <D.20746>;
  <D.20746>:
  D.29377 = 0B;
  return D.29377;
}


mono_class_get_property_token (struct MonoProperty * prop)
{
  struct MonoClassExt * D.29381;
  struct MonoProperty * D.29382;
  unsigned int i.381;
  unsigned int D.29384;
  struct MonoProperty * D.29385;
  uint32_t D.29388;
  unsigned int D.29389;
  unsigned int i.382;
  unsigned int D.29391;
  unsigned int D.29392;
  struct MonoClass * klass;

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

    try
      {
        i = 0;
        iter = 0B;
        goto <D.20755>;
        <D.20754>:
        D.29381 = klass->ext;
        D.29382 = D.29381->properties;
        i.381 = (unsigned int) i;
        D.29384 = i.381 * 20;
        D.29385 = D.29382 + D.29384;
        if (D.29385 == prop) goto <D.29386>; else goto <D.29387>;
        <D.29386>:
        D.29381 = klass->ext;
        D.29389 = D.29381->property.first;
        i.382 = (unsigned int) i;
        D.29391 = D.29389 + i.382;
        D.29392 = D.29391 + 1;
        D.29388 = D.29392 | 385875968;
        return D.29388;
        <D.29387>:
        i = i + 1;
        <D.20755>:
        p = mono_class_get_properties (klass, &iter);
        if (p != 0B) goto <D.20754>; else goto <D.20756>;
        <D.20756>:
        klass = klass->parent;
      }
    finally
      {
        iter = {CLOBBER};
      }
  }
  <D.20758>:
  if (klass != 0B) goto <D.20757>; else goto <D.20759>;
  <D.20759>:
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "class.c", 6953);
  D.29388 = 0;
  return D.29388;
}


mono_class_name_from_token (struct MonoImage * image, guint32 type_token)
{
  unsigned char D.29396;
  unsigned char D.29397;
  char * D.29400;
  unsigned int D.29401;
  <unnamed-unsigned:24> D.29402;
  unsigned int D.29403;
  unsigned int D.29406;
  int D.29407;
  unsigned int D.29408;
  unsigned int D.29409;
  char D.29410;
  <unnamed-unsigned:24> D.29413;
  unsigned int D.29414;
  unsigned int D.29417;
  int D.29418;
  const char * D.29421;
  int D.29422;
  unsigned int D.29423;
  unsigned int D.29424;
  const char * name;
  const char * nspace;

  D.29396 = BIT_FIELD_REF <*image, 8, 128>;
  D.29397 = D.29396 & 8;
  if (D.29397 != 0) goto <D.29398>; else goto <D.29399>;
  <D.29398>:
  D.29400 = monoeg_g_strdup_printf ("DynamicType 0x%08x", type_token);
  return D.29400;
  <D.29399>:
  D.29401 = type_token & 4278190080;
  switch (D.29401) <default: <D.20777>, case 16777216: <D.20770>, case 33554432: <D.20766>, case 452984832: <D.20776>>
  <D.20766>:
  {
    guint32 cols[6];
    struct MonoTableInfo * tt;
    guint tidx;

    try
      {
        tt = &image->tables[2];
        tidx = type_token & 16777215;
        D.29402 = tt->rows;
        D.29403 = (unsigned int) D.29402;
        if (D.29403 < tidx) goto <D.29404>; else goto <D.29405>;
        <D.29404>:
        D.29400 = monoeg_g_strdup_printf ("Invalid type token 0x%08x", type_token);
        return D.29400;
        <D.29405>:
        D.29406 = tidx + 4294967295;
        D.29407 = (int) D.29406;
        mono_metadata_decode_row (tt, D.29407, &cols, 6);
        D.29408 = cols[1];
        name = mono_metadata_string_heap (image, D.29408);
        D.29409 = cols[2];
        nspace = mono_metadata_string_heap (image, D.29409);
        D.29410 = *nspace;
        if (D.29410 == 0) goto <D.29411>; else goto <D.29412>;
        <D.29411>:
        D.29400 = monoeg_g_strdup_printf ("%s", name);
        return D.29400;
        <D.29412>:
        D.29400 = monoeg_g_strdup_printf ("%s.%s", nspace, name);
        return D.29400;
      }
    finally
      {
        cols = {CLOBBER};
      }
  }
  <D.20770>:
  {
    struct MonoError error;
    guint32 cols[3];
    struct MonoTableInfo * t;
    guint tidx;

    try
      {
        t = &image->tables[1];
        tidx = type_token & 16777215;
        D.29413 = t->rows;
        D.29414 = (unsigned int) D.29413;
        if (D.29414 < tidx) goto <D.29415>; else goto <D.29416>;
        <D.29415>:
        D.29400 = monoeg_g_strdup_printf ("Invalid type token 0x%08x", type_token);
        return D.29400;
        <D.29416>:
        D.29417 = tidx + 4294967295;
        D.29418 = mono_verifier_verify_typeref_row (image, D.29417, &error);
        if (D.29418 == 0) goto <D.29419>; else goto <D.29420>;
        <D.29419>:
        {
          char * msg;

          D.29421 = mono_error_get_message (&error);
          msg = monoeg_g_strdup_printf ("Invalid type token 0x%08x due to \'%s\'", type_token, D.29421);
          mono_error_cleanup (&error);
          D.29400 = msg;
          return D.29400;
        }
        <D.29420>:
        D.29417 = tidx + 4294967295;
        D.29422 = (int) D.29417;
        mono_metadata_decode_row (t, D.29422, &cols, 3);
        D.29423 = cols[1];
        name = mono_metadata_string_heap (image, D.29423);
        D.29424 = cols[2];
        nspace = mono_metadata_string_heap (image, D.29424);
        D.29410 = *nspace;
        if (D.29410 == 0) goto <D.29425>; else goto <D.29426>;
        <D.29425>:
        D.29400 = monoeg_g_strdup_printf ("%s", name);
        return D.29400;
        <D.29426>:
        D.29400 = monoeg_g_strdup_printf ("%s.%s", nspace, name);
        return D.29400;
      }
    finally
      {
        error = {CLOBBER};
        cols = {CLOBBER};
      }
  }
  <D.20776>:
  D.29400 = monoeg_g_strdup_printf ("Typespec 0x%08x", type_token);
  return D.29400;
  <D.20777>:
  D.29400 = monoeg_g_strdup_printf ("Invalid type token 0x%08x", type_token);
  return D.29400;
}


mono_class_get_full (struct MonoImage * image, guint32 type_token, struct MonoGenericContext * context)
{
  unsigned char D.29430;
  unsigned char D.29431;
  unsigned int D.29434;
  unsigned int table.383;
  unsigned int D.29436;
  _Bool D.29437;
  _Bool D.29438;
  _Bool D.29439;
  gchar * D.29442;
  struct MonoClass * D.29443;
  unsigned int D.29444;
  int D.29445;
  int D.29448;
  struct MonoError error;
  struct MonoClass * class;

  try
    {
      class = 0B;
      D.29430 = BIT_FIELD_REF <*image, 8, 128>;
      D.29431 = D.29430 & 8;
      if (D.29431 != 0) goto <D.29432>; else goto <D.29433>;
      <D.29432>:
      {
        int table;

        D.29434 = type_token >> 24;
        table = (int) D.29434;
        table.383 = (unsigned int) table;
        D.29436 = table.383 + 4294967295;
        D.29437 = D.29436 > 1;
        D.29438 = table != 27;
        D.29439 = D.29437 & D.29438;
        if (D.29439 != 0) goto <D.29440>; else goto <D.29441>;
        <D.29440>:
        D.29442 = monoeg_strdup ("Bad type token.");
        mono_loader_set_error_bad_image (D.29442);
        D.29443 = 0B;
        return D.29443;
        <D.29441>:
        D.29443 = mono_lookup_dynamic_token (image, type_token, context);
        return D.29443;
      }
      <D.29433>:
      D.29444 = type_token & 4278190080;
      switch (D.29444) <default: <D.20810>, case 16777216: <D.20808>, case 33554432: <D.20806>, case 452984832: <D.20809>>
      <D.20806>:
      class = mono_class_create_from_typedef (image, type_token, &error);
      D.29445 = mono_error_ok (&error);
      if (D.29445 == 0) goto <D.29446>; else goto <D.29447>;
      <D.29446>:
      mono_loader_set_error_from_mono_error (&error);
      mono_error_cleanup (&error);
      D.29443 = 0B;
      return D.29443;
      <D.29447>:
      goto <D.20807>;
      <D.20808>:
      class = mono_class_from_typeref (image, type_token);
      goto <D.20807>;
      <D.20809>:
      class = mono_class_create_from_typespec (image, type_token, context, &error);
      D.29448 = mono_error_ok (&error);
      if (D.29448 == 0) goto <D.29449>; else goto <D.29450>;
      <D.29449>:
      mono_error_cleanup (&error);
      <D.29450>:
      goto <D.20807>;
      <D.20810>:
      D.29444 = type_token & 4278190080;
      monoeg_g_log (0B, 16, "unknown token type %x", D.29444);
      monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "class.c", 7118);
      <D.20807>:
      if (class == 0B) goto <D.29451>; else goto <D.29452>;
      <D.29451>:
      {
        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.29452>:
      D.29443 = class;
      return D.29443;
    }
  finally
    {
      error = {CLOBBER};
    }
}


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

  try
    {
      inflated = 0;
      t = mono_type_retrieve_from_typespec (image, type_spec, context, &inflated, error);
      D.29455 = mono_error_ok (error);
      if (D.29455 == 0) goto <D.29456>; else goto <D.29457>;
      <D.29456>:
      D.29458 = 0B;
      return D.29458;
      <D.29457>:
      ret = mono_class_from_mono_type (t);
      inflated.384 = inflated;
      if (inflated.384 != 0) goto <D.29460>; else goto <D.29461>;
      <D.29460>:
      mono_metadata_free_type (t);
      <D.29461>:
      D.29458 = ret;
      return D.29458;
    }
  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.29466;
  struct MonoGenericInst * D.29471;
  struct MonoGenericInst * D.29473;
  int D.29474;
  struct MonoType * t;

  t = mono_type_create_from_typespec (image, type_spec);
  mono_error_init (error);
  *did_inflate = 0;
  if (t == 0B) goto <D.29464>; else goto <D.29465>;
  <D.29464>:
  {
    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.29466 = 0B;
    return D.29466;
  }
  <D.29465>:
  if (context != 0B) goto <D.29469>; else goto <D.29470>;
  <D.29469>:
  D.29471 = context->class_inst;
  if (D.29471 != 0B) goto <D.29467>; else goto <D.29472>;
  <D.29472>:
  D.29473 = context->method_inst;
  if (D.29473 != 0B) goto <D.29467>; else goto <D.29468>;
  <D.29467>:
  {
    struct MonoType * inflated;

    inflated = inflate_generic_type (0B, t, context, error);
    D.29474 = mono_error_ok (error);
    if (D.29474 == 0) goto <D.29475>; else goto <D.29476>;
    <D.29475>:
    D.29466 = 0B;
    return D.29466;
    <D.29476>:
    if (inflated != 0B) goto <D.29477>; else goto <D.29478>;
    <D.29477>:
    t = inflated;
    *did_inflate = 1;
    <D.29478>:
  }
  <D.29468>:
  <D.29470>:
  D.29466 = t;
  return D.29466;
}


mono_assembly_name_from_token (struct MonoImage * image, guint32 type_token)
{
  unsigned char D.29480;
  unsigned char D.29481;
  char * D.29484;
  char * D.29485;
  unsigned int D.29486;
  struct MonoAssembly * D.29487;
  struct MonoAssemblyName * D.29490;
  const char * D.29491;
  const char * iftmp.385;
  <unnamed-unsigned:24> D.29498;
  unsigned int D.29499;
  unsigned int D.29502;
  int D.29503;
  const char * D.29506;
  int D.29507;
  unsigned int D.29508;
  unsigned int D.29509;

  D.29480 = BIT_FIELD_REF <*image, 8, 128>;
  D.29481 = D.29480 & 8;
  if (D.29481 != 0) goto <D.29482>; else goto <D.29483>;
  <D.29482>:
  D.29485 = image->name;
  D.29484 = monoeg_g_strdup_printf ("DynamicAssembly %s", D.29485);
  return D.29484;
  <D.29483>:
  D.29486 = type_token & 4278190080;
  switch (D.29486) <default: <D.20797>, case 16777216: <D.20783>, case 33554432: <D.20782>, case 452984832: <D.20796>>
  <D.20782>:
  D.29487 = image->assembly;
  if (D.29487 != 0B) goto <D.29488>; else goto <D.29489>;
  <D.29488>:
  D.29487 = image->assembly;
  D.29490 = &D.29487->aname;
  D.29484 = mono_stringify_assembly_name (D.29490);
  return D.29484;
  <D.29489>:
  D.29491 = image->assembly_name;
  if (D.29491 != 0B) goto <D.29492>; else goto <D.29493>;
  <D.29492>:
  D.29491 = image->assembly_name;
  D.29484 = monoeg_strdup (D.29491);
  return D.29484;
  <D.29493>:
  D.29485 = image->name;
  if (D.29485 != 0B) goto <D.29495>; else goto <D.29496>;
  <D.29495>:
  iftmp.385 = image->name;
  goto <D.29497>;
  <D.29496>:
  iftmp.385 = "[Could not resolve assembly name";
  <D.29497>:
  D.29484 = monoeg_g_strdup_printf ("%s", iftmp.385);
  return D.29484;
  <D.20783>:
  {
    struct MonoError error;
    struct MonoAssemblyName aname;
    guint32 cols[3];
    struct MonoTableInfo * t;
    guint32 idx;

    try
      {
        t = &image->tables[1];
        idx = type_token & 16777215;
        D.29498 = t->rows;
        D.29499 = (unsigned int) D.29498;
        if (D.29499 < idx) goto <D.29500>; else goto <D.29501>;
        <D.29500>:
        D.29484 = monoeg_g_strdup_printf ("Invalid type token 0x%08x", type_token);
        return D.29484;
        <D.29501>:
        D.29502 = idx + 4294967295;
        D.29503 = mono_verifier_verify_typeref_row (image, D.29502, &error);
        if (D.29503 == 0) goto <D.29504>; else goto <D.29505>;
        <D.29504>:
        {
          char * msg;

          D.29506 = mono_error_get_message (&error);
          msg = monoeg_g_strdup_printf ("Invalid type token 0x%08x due to \'%s\'", type_token, D.29506);
          mono_error_cleanup (&error);
          D.29484 = msg;
          return D.29484;
        }
        <D.29505>:
        D.29502 = idx + 4294967295;
        D.29507 = (int) D.29502;
        mono_metadata_decode_row (t, D.29507, &cols, 3);
        D.29508 = cols[0];
        idx = D.29508 >> 2;
        D.29508 = cols[0];
        D.29509 = D.29508 & 3;
        switch (D.29509) <default: <D.20794>, case 0: <D.20790>, case 1: <D.20791>, case 2: <D.20793>, case 3: <D.20792>>
        <D.20790>:
        D.29484 = monoeg_strdup ("");
        return D.29484;
        <D.20791>:
        D.29484 = monoeg_strdup ("");
        return D.29484;
        <D.20792>:
        D.29484 = monoeg_strdup ("");
        return D.29484;
        <D.20793>:
        D.29502 = idx + 4294967295;
        D.29507 = (int) D.29502;
        mono_assembly_get_assemblyref (image, D.29507, &aname);
        D.29484 = mono_stringify_assembly_name (&aname);
        return D.29484;
        <D.20794>:
        monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "class.c", 7058);
        goto <D.20795>;
      }
    finally
      {
        error = {CLOBBER};
        aname = {CLOBBER};
        cols = {CLOBBER};
      }
  }
  <D.20796>:
  D.29484 = monoeg_strdup ("");
  return D.29484;
  <D.20797>:
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "class.c", 7066);
  <D.20795>:
  D.29484 = 0B;
  return D.29484;
}


mono_type_get_full (struct MonoImage * image, guint32 type_token, struct MonoGenericContext * context)
{
  unsigned char D.29513;
  unsigned char D.29514;
  struct MonoType * D.29517;
  void * D.29518;
  unsigned int D.29519;
  struct MonoType * iftmp.386;
  int D.29526;
  const char * D.29529;
  int inflated.387;
  struct MonoClass * D.29533;
  unsigned char D.29534;
  unsigned char D.29535;
  struct MonoError error;
  struct MonoType * type;
  gboolean inflated;

  try
    {
      type = 0B;
      inflated = 0;
      D.29513 = BIT_FIELD_REF <*image, 8, 128>;
      D.29514 = D.29513 & 8;
      if (D.29514 != 0) goto <D.29515>; else goto <D.29516>;
      <D.29515>:
      D.29518 = mono_lookup_dynamic_token (image, type_token, context);
      D.29517 = mono_class_get_type (D.29518);
      return D.29517;
      <D.29516>:
      D.29519 = type_token & 4278190080;
      if (D.29519 != 452984832) goto <D.29520>; else goto <D.29521>;
      <D.29520>:
      {
        struct MonoClass * class;

        class = mono_class_get_full (image, type_token, context);
        if (class != 0B) goto <D.29523>; else goto <D.29524>;
        <D.29523>:
        iftmp.386 = mono_class_get_type (class);
        goto <D.29525>;
        <D.29524>:
        iftmp.386 = 0B;
        <D.29525>:
        D.29517 = iftmp.386;
        return D.29517;
      }
      <D.29521>:
      type = mono_type_retrieve_from_typespec (image, type_token, context, &inflated, &error);
      D.29526 = mono_error_ok (&error);
      if (D.29526 == 0) goto <D.29527>; else goto <D.29528>;
      <D.29527>:
      {
        char * name;
        char * assembly;

        name = mono_class_name_from_token (image, type_token);
        assembly = mono_assembly_name_from_token (image, type_token);
        D.29529 = mono_error_get_message (&error);
        monoeg_g_log (0B, 16, "Error loading type %s from %s due to %s", name, assembly, D.29529);
        mono_error_cleanup (&error);
        mono_loader_set_error_type_load (name, assembly);
        D.29517 = 0B;
        return D.29517;
      }
      <D.29528>:
      inflated.387 = inflated;
      if (inflated.387 != 0) goto <D.29531>; else goto <D.29532>;
      <D.29531>:
      {
        struct MonoType * tmp;

        tmp = type;
        D.29533 = mono_class_from_mono_type (type);
        type = mono_class_get_type (D.29533);
        D.29534 = type->type;
        D.29535 = tmp->type;
        if (D.29534 != D.29535) goto <D.29536>; else goto <D.29537>;
        <D.29536>:
        type = tmp;
        goto <D.29538>;
        <D.29537>:
        mono_metadata_free_type (tmp);
        <D.29538>:
      }
      <D.29532>:
      D.29517 = type;
      return D.29517;
    }
  finally
    {
      error = {CLOBBER};
      inflated = {CLOBBER};
    }
}


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

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


mono_image_init_name_cache (struct MonoImage * image)
{
  struct GHashTable * D.29543;
  struct GHashTable * D.29546;
  unsigned char D.29547;
  unsigned char D.29548;
  unsigned int D.29551;
  int D.29552;
  unsigned int D.29553;
  unsigned int D.29554;
  unsigned int D.29557;
  unsigned int D.29558;
  const void * nspace_index.388;
  void * nspace_index.389;
  void * i.390;
  <unnamed-unsigned:24> D.29564;
  unsigned int D.29565;
  unsigned int D.29566;
  unsigned int D.29567;
  int D.29570;
  int D.29571;
  void * D.29572;
  <unnamed-unsigned:24> D.29573;
  int D.29574;
  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.29543 = image->name_cache;
      if (D.29543 != 0B) goto <D.29544>; else goto <D.29545>;
      <D.29544>:
      mono_image_unlock (image);
      return;
      <D.29545>:
      D.29546 = monoeg_g_hash_table_new (monoeg_g_str_hash, monoeg_g_str_equal);
      image->name_cache = D.29546;
      D.29547 = BIT_FIELD_REF <*image, 8, 128>;
      D.29548 = D.29547 & 8;
      if (D.29548 != 0) goto <D.29549>; else goto <D.29550>;
      <D.29549>:
      mono_image_unlock (image);
      return;
      <D.29550>:
      name_cache2 = monoeg_g_hash_table_new (0B, 0B);
      i = 1;
      goto <D.20843>;
      <D.20842>:
      D.29551 = i + 4294967295;
      D.29552 = (int) D.29551;
      mono_metadata_decode_row (t, D.29552, &cols, 6);
      D.29553 = cols[0];
      visib = D.29553 & 7;
      D.29554 = visib + 4294967294;
      if (D.29554 <= 5) goto <D.29555>; else goto <D.29556>;
      <D.29555>:
      // predicted unlikely by continue predictor.
      goto <D.20841>;
      <D.29556>:
      D.29557 = cols[1];
      name = mono_metadata_string_heap (image, D.29557);
      D.29558 = cols[2];
      nspace = mono_metadata_string_heap (image, D.29558);
      nspace_index = cols[2];
      nspace_index.388 = (const void *) nspace_index;
      nspace_table = monoeg_g_hash_table_lookup (name_cache2, nspace_index.388);
      if (nspace_table == 0B) goto <D.29560>; else goto <D.29561>;
      <D.29560>:
      nspace_table = monoeg_g_hash_table_new (monoeg_g_str_hash, monoeg_g_str_equal);
      D.29543 = image->name_cache;
      monoeg_g_hash_table_insert_replace (D.29543, nspace, nspace_table, 0);
      nspace_index.389 = (void *) nspace_index;
      monoeg_g_hash_table_insert_replace (name_cache2, nspace_index.389, nspace_table, 0);
      <D.29561>:
      i.390 = (void *) i;
      monoeg_g_hash_table_insert_replace (nspace_table, name, i.390, 0);
      <D.20841>:
      i = i + 1;
      <D.20843>:
      D.29564 = t->rows;
      D.29565 = (unsigned int) D.29564;
      if (D.29565 >= i) goto <D.20842>; else goto <D.20844>;
      <D.20844>:
      {
        struct MonoTableInfo * t;
        guint32 cols[5];
        int i;

        try
          {
            t = &image->tables[39];
            i = 0;
            goto <D.20849>;
            <D.20848>:
            mono_metadata_decode_row (t, i, &cols, 5);
            D.29566 = cols[2];
            name = mono_metadata_string_heap (image, D.29566);
            D.29567 = cols[3];
            nspace = mono_metadata_string_heap (image, D.29567);
            nspace_index = cols[3];
            nspace_index.388 = (const void *) nspace_index;
            nspace_table = monoeg_g_hash_table_lookup (name_cache2, nspace_index.388);
            if (nspace_table == 0B) goto <D.29568>; else goto <D.29569>;
            <D.29568>:
            nspace_table = monoeg_g_hash_table_new (monoeg_g_str_hash, monoeg_g_str_equal);
            D.29543 = image->name_cache;
            monoeg_g_hash_table_insert_replace (D.29543, nspace, nspace_table, 0);
            nspace_index.389 = (void *) nspace_index;
            monoeg_g_hash_table_insert_replace (name_cache2, nspace_index.389, nspace_table, 0);
            <D.29569>:
            D.29570 = i + 1;
            D.29571 = D.29570 | 654311424;
            D.29572 = (void *) D.29571;
            monoeg_g_hash_table_insert_replace (nspace_table, name, D.29572, 0);
            i = i + 1;
            <D.20849>:
            D.29573 = t->rows;
            D.29574 = (int) D.29573;
            if (D.29574 > i) goto <D.20848>; else goto <D.20850>;
            <D.20850>:
          }
        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.29578;
  void * D.29583;
  char * D.29586;
  void * index.391;
  struct GHashTable * nspace_table;
  struct GHashTable * name_cache;
  guint32 old_index;

  mono_image_lock (image);
  D.29578 = image->name_cache;
  if (D.29578 == 0B) goto <D.29579>; else goto <D.29580>;
  <D.29579>:
  mono_image_init_name_cache (image);
  <D.29580>:
  name_cache = image->name_cache;
  nspace_table = monoeg_g_hash_table_lookup (name_cache, nspace);
  if (nspace_table == 0B) goto <D.29581>; else goto <D.29582>;
  <D.29581>:
  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.29582>:
  D.29583 = monoeg_g_hash_table_lookup (nspace_table, name);
  old_index = (guint32) D.29583;
  if (old_index != 0) goto <D.29584>; else goto <D.29585>;
  <D.29584>:
  D.29586 = image->name;
  monoeg_g_log (0B, 4, "overrwritting old token %x on image %s for type %s::%s", old_index, D.29586, nspace, name);
  <D.20860>:
  goto <D.20860>;
  <D.29585>:
  index.391 = (void *) index;
  monoeg_g_hash_table_insert_replace (nspace_table, name, index.391, 0);
  mono_image_unlock (image);
}


mono_class_from_name_case (struct MonoImage * image, const char * name_space, const char * name)
{
  unsigned char D.29588;
  unsigned char D.29589;
  struct GHashTable * D.29592;
  void * D.29595;
  struct MonoClass * D.29602;
  unsigned int D.29603;
  unsigned int D.29604;
  int D.29605;
  unsigned int D.29606;
  unsigned int D.29607;
  unsigned int D.29610;
  unsigned int D.29611;
  int D.29612;
  int D.29615;
  unsigned int D.29618;
  <unnamed-unsigned:24> D.29619;
  unsigned int D.29620;
  struct MonoTableInfo * t;
  guint32 cols[6];
  const char * n;
  const char * nspace;
  guint32 i;
  guint32 visib;

  try
    {
      t = &image->tables[2];
      D.29588 = BIT_FIELD_REF <*image, 8, 128>;
      D.29589 = D.29588 & 8;
      if (D.29589 != 0) goto <D.29590>; else goto <D.29591>;
      <D.29590>:
      {
        guint32 token;
        struct FindUserData user_data;

        try
          {
            token = 0;
            mono_image_lock (image);
            D.29592 = image->name_cache;
            if (D.29592 == 0B) goto <D.29593>; else goto <D.29594>;
            <D.29593>:
            mono_image_init_name_cache (image);
            <D.29594>:
            user_data.key = name_space;
            user_data.value = 0B;
            D.29592 = image->name_cache;
            monoeg_g_hash_table_foreach (D.29592, find_nocase, &user_data);
            D.29595 = user_data.value;
            if (D.29595 != 0B) goto <D.29596>; else goto <D.29597>;
            <D.29596>:
            {
              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.29595 = user_data.value;
              if (D.29595 != 0B) goto <D.29598>; else goto <D.29599>;
              <D.29598>:
              D.29595 = user_data.value;
              token = (guint32) D.29595;
              <D.29599>:
            }
            <D.29597>:
            mono_image_unlock (image);
            if (token != 0) goto <D.29600>; else goto <D.29601>;
            <D.29600>:
            D.29603 = token | 33554432;
            D.29602 = mono_class_get (image, D.29603);
            return D.29602;
            <D.29601>:
            D.29602 = 0B;
            return D.29602;
          }
        finally
          {
            user_data = {CLOBBER};
          }
      }
      <D.29591>:
      i = 1;
      goto <D.20888>;
      <D.20887>:
      D.29604 = i + 4294967295;
      D.29605 = (int) D.29604;
      mono_metadata_decode_row (t, D.29605, &cols, 6);
      D.29606 = cols[0];
      visib = D.29606 & 7;
      D.29607 = visib + 4294967294;
      if (D.29607 <= 5) goto <D.29608>; else goto <D.29609>;
      <D.29608>:
      // predicted unlikely by continue predictor.
      goto <D.20886>;
      <D.29609>:
      D.29610 = cols[1];
      n = mono_metadata_string_heap (image, D.29610);
      D.29611 = cols[2];
      nspace = mono_metadata_string_heap (image, D.29611);
      D.29612 = monoeg_ascii_strcasecmp (n, name);
      if (D.29612 == 0) goto <D.29613>; else goto <D.29614>;
      <D.29613>:
      D.29615 = monoeg_ascii_strcasecmp (nspace, name_space);
      if (D.29615 == 0) goto <D.29616>; else goto <D.29617>;
      <D.29616>:
      D.29618 = i | 33554432;
      D.29602 = mono_class_get (image, D.29618);
      return D.29602;
      <D.29617>:
      <D.29614>:
      <D.20886>:
      i = i + 1;
      <D.20888>:
      D.29619 = t->rows;
      D.29620 = (unsigned int) D.29619;
      if (D.29620 >= i) goto <D.20887>; else goto <D.20889>;
      <D.20889>:
      D.29602 = 0B;
      return D.29602;
    }
  finally
    {
      cols = {CLOBBER};
    }
}


find_nocase (void * key, void * value, void * user_data)
{
  void * D.29624;
  const void * D.29627;
  int D.29628;
  char * name;
  struct FindUserData * data;

  name = key;
  data = user_data;
  D.29624 = data->value;
  if (D.29624 == 0B) goto <D.29625>; else goto <D.29626>;
  <D.29625>:
  D.29627 = data->key;
  D.29628 = monoeg_ascii_strcasecmp (name, D.29627);
  if (D.29628 == 0) goto <D.29629>; else goto <D.29630>;
  <D.29629>:
  data->value = value;
  <D.29630>:
  <D.29626>:
}


mono_class_from_name (struct MonoImage * image, const char * name_space, const char * name)
{
  int nested.392;
  int name.393;
  unsigned int D.29635;
  struct MonoClass * D.29638;
  int D.29639;
  unsigned int D.29640;
  sizetype pos.394;
  sizetype D.29642;
  gboolean (*<T1e2b>) (struct MonoImage *, const char *, const char *, struct MonoClass * *) get_class_from_name.395;
  unsigned int D.29646;
  unsigned int D.29647;
  struct MonoClass * class.396;
  struct MonoClass * class.397;
  struct MonoClass * iftmp.398;
  struct GHashTable * D.29662;
  void * D.29667;
  unsigned char D.29670;
  unsigned char D.29671;
  struct MonoImage * * D.29674;
  unsigned int i.399;
  unsigned int D.29678;
  struct MonoImage * * D.29679;
  struct MonoClass * class.400;
  unsigned int i.401;
  unsigned int D.29684;
  struct MonoClass * class.402;
  unsigned int D.29692;
  unsigned int D.29695;
  int D.29696;
  unsigned int D.29697;
  unsigned int D.29700;
  struct MonoAssembly * D.29701;
  struct MonoClass * class.403;
  unsigned int D.29709;
  int D.29710;
  struct MonoAssembly * * D.29711;
  sizetype D.29712;
  sizetype D.29713;
  struct MonoAssembly * * D.29714;
  struct MonoAssembly * D.29715;
  _Bool D.29716;
  long int D.29717;
  long int D.29718;
  struct MonoImage * D.29723;
  struct MonoClass * class.404;
  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.29631>; else goto <D.29632>;
      <D.29631>:
      {
        int pos;
        int len;

        nested.392 = (int) nested;
        name.393 = (int) name;
        pos = nested.392 - name.393;
        D.29635 = strlen (name);
        len = (int) D.29635;
        if (len > 1023) goto <D.29636>; else goto <D.29637>;
        <D.29636>:
        D.29638 = 0B;
        return D.29638;
        <D.29637>:
        D.29639 = len + 1;
        D.29640 = (unsigned int) D.29639;
        memcpy (&buf, name, D.29640);
        buf[pos] = 0;
        pos.394 = (sizetype) pos;
        D.29642 = pos.394 + 1;
        nested = &buf + D.29642;
        name = &buf;
      }
      <D.29632>:
      get_class_from_name.395 = get_class_from_name;
      if (get_class_from_name.395 != 0B) goto <D.29644>; else goto <D.29645>;
      <D.29644>:
      D.29646 = BIT_FIELD_REF <*image, 32, 4576>;
      D.29647 = D.29646 & 16777215;
      if (D.29647 == 0) goto <D.29648>; else goto <D.29649>;
      <D.29648>:
      {
        gboolean res;

        get_class_from_name.395 = get_class_from_name;
        res = get_class_from_name.395 (image, name_space, name, &class);
        if (res != 0) goto <D.29650>; else goto <D.29651>;
        <D.29650>:
        class.396 = class;
        if (class.396 == 0B) goto <D.29653>; else goto <D.29654>;
        <D.29653>:
        class.397 = search_modules (image, name_space, name);
        class = class.397;
        <D.29654>:
        if (nested != 0B) goto <D.29656>; else goto <D.29657>;
        <D.29656>:
        class.396 = class;
        if (class.396 != 0B) goto <D.29659>; else goto <D.29660>;
        <D.29659>:
        class.396 = class;
        iftmp.398 = return_nested_in (class.396, nested);
        goto <D.29661>;
        <D.29660>:
        iftmp.398 = 0B;
        <D.29661>:
        D.29638 = iftmp.398;
        return D.29638;
        <D.29657>:
        D.29638 = class;
        return D.29638;
        <D.29651>:
      }
      <D.29649>:
      <D.29645>:
      mono_image_lock (image);
      D.29662 = image->name_cache;
      if (D.29662 == 0B) goto <D.29663>; else goto <D.29664>;
      <D.29663>:
      mono_image_init_name_cache (image);
      <D.29664>:
      D.29662 = image->name_cache;
      nspace_table = monoeg_g_hash_table_lookup (D.29662, name_space);
      if (nspace_table != 0B) goto <D.29665>; else goto <D.29666>;
      <D.29665>:
      D.29667 = monoeg_g_hash_table_lookup (nspace_table, name);
      token = (guint32) D.29667;
      <D.29666>:
      mono_image_unlock (image);
      if (token == 0) goto <D.29668>; else goto <D.29669>;
      <D.29668>:
      D.29670 = BIT_FIELD_REF <*image, 8, 128>;
      D.29671 = D.29670 & 8;
      if (D.29671 != 0) goto <D.29672>; else goto <D.29673>;
      <D.29672>:
      D.29674 = image->modules;
      if (D.29674 != 0B) goto <D.29675>; else goto <D.29676>;
      <D.29675>:
      i = 0;
      goto <D.20940>;
      <D.20939>:
      {
        struct MonoImage * module;

        D.29674 = image->modules;
        i.399 = (unsigned int) i;
        D.29678 = i.399 * 4;
        D.29679 = D.29674 + D.29678;
        module = *D.29679;
        class.400 = mono_class_from_name (module, name_space, name);
        class = class.400;
        class.396 = class;
        if (class.396 != 0B) goto <D.29681>; else goto <D.29682>;
        <D.29681>:
        D.29638 = class;
        return D.29638;
        <D.29682>:
      }
      i = i + 1;
      <D.20940>:
      i.401 = (unsigned int) i;
      D.29684 = image->module_count;
      if (i.401 < D.29684) goto <D.20939>; else goto <D.20941>;
      <D.20941>:
      <D.29676>:
      <D.29673>:
      <D.29669>:
      if (token == 0) goto <D.29685>; else goto <D.29686>;
      <D.29685>:
      class.402 = search_modules (image, name_space, name);
      class = class.402;
      class.396 = class;
      if (class.396 != 0B) goto <D.29688>; else goto <D.29689>;
      <D.29688>:
      D.29638 = class;
      return D.29638;
      <D.29689>:
      <D.29686>:
      if (token == 0) goto <D.29690>; else goto <D.29691>;
      <D.29690>:
      D.29638 = 0B;
      return D.29638;
      <D.29691>:
      D.29692 = token >> 24;
      if (D.29692 == 39) goto <D.29693>; else goto <D.29694>;
      <D.29693>:
      {
        struct MonoTableInfo * t;
        guint32 cols[5];
        guint32 idx;
        guint32 impl;

        try
          {
            t = &image->tables[39];
            idx = token & 16777215;
            D.29695 = idx + 4294967295;
            D.29696 = (int) D.29695;
            mono_metadata_decode_row (t, D.29696, &cols, 5);
            impl = cols[4];
            D.29697 = impl & 3;
            if (D.29697 == 0) goto <D.29698>; else goto <D.29699>;
            <D.29698>:
            D.29700 = impl >> 2;
            D.29701 = image->assembly;
            loaded_image = mono_assembly_load_module (D.29701, D.29700);
            if (loaded_image == 0B) goto <D.29702>; else goto <D.29703>;
            <D.29702>:
            D.29638 = 0B;
            return D.29638;
            <D.29703>:
            class.403 = mono_class_from_name (loaded_image, name_space, name);
            class = class.403;
            if (nested != 0B) goto <D.29705>; else goto <D.29706>;
            <D.29705>:
            class.396 = class;
            D.29638 = return_nested_in (class.396, nested);
            return D.29638;
            <D.29706>:
            D.29638 = class;
            return D.29638;
            <D.29699>:
            D.29697 = impl & 3;
            if (D.29697 == 1) goto <D.29707>; else goto <D.29708>;
            <D.29707>:
            {
              guint32 assembly_idx;

              assembly_idx = impl >> 2;
              D.29709 = assembly_idx + 4294967295;
              D.29710 = (int) D.29709;
              mono_assembly_load_reference (image, D.29710);
              D.29711 = image->references;
              D.29712 = assembly_idx + 1073741823;
              D.29713 = D.29712 * 4;
              D.29714 = D.29711 + D.29713;
              D.29715 = *D.29714;
              D.29716 = D.29715 == 0B;
              D.29717 = (long int) D.29716;
              D.29718 = __builtin_expect (D.29717, 0);
              if (D.29718 != 0) goto <D.29719>; else goto <D.29720>;
              <D.29719>:
              monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "class.c", 7552, "image->references [assembly_idx - 1]");
              <D.29720>:
              D.29711 = image->references;
              D.29712 = assembly_idx + 1073741823;
              D.29713 = D.29712 * 4;
              D.29714 = D.29711 + D.29713;
              D.29715 = *D.29714;
              if (D.29715 == 4294967295B) goto <D.29721>; else goto <D.29722>;
              <D.29721>:
              D.29638 = 0B;
              return D.29638;
              <D.29722>:
              D.29711 = image->references;
              D.29712 = assembly_idx + 1073741823;
              D.29713 = D.29712 * 4;
              D.29714 = D.29711 + D.29713;
              D.29715 = *D.29714;
              D.29723 = D.29715->image;
              D.29638 = mono_class_from_name (D.29723, name_space, name);
              return D.29638;
            }
            <D.29708>:
            monoeg_g_log (0B, 4, "not yet implemented");
            <D.20947>:
            goto <D.20947>;
          }
        finally
          {
            cols = {CLOBBER};
          }
      }
      <D.29694>:
      token = token | 33554432;
      class.404 = mono_class_get (image, token);
      class = class.404;
      if (nested != 0B) goto <D.29725>; else goto <D.29726>;
      <D.29725>:
      class.396 = class;
      D.29638 = return_nested_in (class.396, nested);
      return D.29638;
      <D.29726>:
      D.29638 = class;
      return D.29638;
    }
  finally
    {
      class = {CLOBBER};
      buf = {CLOBBER};
    }
}


search_modules (struct MonoImage * image, const char * name_space, const char * name)
{
  unsigned int D.29730;
  int D.29733;
  struct MonoClass * D.29738;
  <unnamed-unsigned:24> D.29739;
  int D.29740;
  struct MonoTableInfo * file_table;
  struct MonoImage * file_image;
  struct MonoClass * class;
  int i;

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

    try
      {
        mono_metadata_decode_row (file_table, i, &cols, 3);
        D.29730 = cols[0];
        if (D.29730 == 1) goto <D.29731>; else goto <D.29732>;
        <D.29731>:
        // predicted unlikely by continue predictor.
        goto <D.20919>;
        <D.29732>:
        D.29733 = i + 1;
        file_image = mono_image_load_file_for_image (image, D.29733);
        if (file_image != 0B) goto <D.29734>; else goto <D.29735>;
        <D.29734>:
        class = mono_class_from_name (file_image, name_space, name);
        if (class != 0B) goto <D.29736>; else goto <D.29737>;
        <D.29736>:
        D.29738 = class;
        return D.29738;
        <D.29737>:
        <D.29735>:
      }
    finally
      {
        cols = {CLOBBER};
      }
  }
  <D.20919>:
  i = i + 1;
  <D.20921>:
  D.29739 = file_table->rows;
  D.29740 = (int) D.29739;
  if (D.29740 > i) goto <D.20920>; else goto <D.20922>;
  <D.20922>:
  D.29738 = 0B;
  return D.29738;
}


return_nested_in (struct MonoClass * class, char * nested)
{
  int D.20905;
  const char * D.29747;
  struct MonoClass * D.29752;
  struct MonoClass * found;
  char * s;
  void * iter;

  try
    {
      s = __builtin_strchr (nested, 47);
      iter = 0B;
      if (s != 0B) goto <D.29745>; else goto <D.29746>;
      <D.29745>:
      *s = 0;
      s = s + 1;
      <D.29746>:
      goto <D.20907>;
      <D.20906>:
      {
        size_t __s1_len;
        size_t __s2_len;

        D.29747 = found->name;
        D.20905 = __builtin_strcmp (D.29747, nested);
      }
      if (D.20905 == 0) goto <D.29748>; else goto <D.29749>;
      <D.29748>:
      if (s != 0B) goto <D.29750>; else goto <D.29751>;
      <D.29750>:
      D.29752 = return_nested_in (found, s);
      return D.29752;
      <D.29751>:
      D.29752 = found;
      return D.29752;
      <D.29749>:
      <D.20907>:
      found = mono_class_get_nested_types (class, &iter);
      if (found != 0B) goto <D.20906>; else goto <D.20908>;
      <D.20908>:
      D.29752 = 0B;
      return D.29752;
    }
  finally
    {
      iter = {CLOBBER};
    }
}


mono_class_is_subclass_of (struct MonoClass * klass, struct MonoClass * klassc, gboolean check_interfaces)
{
  unsigned int D.29759;
  unsigned int D.29760;
  unsigned char D.29762;
  unsigned int D.29764;
  unsigned int D.29765;
  unsigned char D.29767;
  short unsigned int D.29770;
  short unsigned int D.29771;
  guint8 * D.29774;
  short unsigned int D.29775;
  sizetype D.29776;
  guint8 * D.29777;
  unsigned char D.29778;
  int D.29779;
  int D.29780;
  int D.29781;
  int D.29782;
  int D.29783;
  mono_bool D.29786;
  struct MonoClass * * D.29796;
  unsigned int i.405;
  unsigned int D.29798;
  struct MonoClass * * D.29799;
  short unsigned int D.29802;
  int D.29803;
  int D.29810;
  struct MonoClass * D.29813;

  if (check_interfaces != 0) goto <D.29758>; else goto <D.29755>;
  <D.29758>:
  D.29759 = klassc->flags;
  D.29760 = D.29759 & 32;
  if (D.29760 != 0) goto <D.29756>; else goto <D.29761>;
  <D.29761>:
  D.29762 = klassc->byval_arg.type;
  if (D.29762 == 19) goto <D.29756>; else goto <D.29763>;
  <D.29763>:
  D.29762 = klassc->byval_arg.type;
  if (D.29762 == 30) goto <D.29756>; else goto <D.29755>;
  <D.29756>:
  D.29764 = klass->flags;
  D.29765 = D.29764 & 32;
  if (D.29765 == 0) goto <D.29766>; else goto <D.29755>;
  <D.29766>:
  D.29767 = klass->byval_arg.type;
  if (D.29767 != 19) goto <D.29768>; else goto <D.29755>;
  <D.29768>:
  D.29767 = klass->byval_arg.type;
  if (D.29767 != 30) goto <D.29769>; else goto <D.29755>;
  <D.29769>:
  D.29770 = klassc->interface_id;
  D.29771 = klass->max_interface_id;
  if (D.29770 <= D.29771) goto <D.29772>; else goto <D.29773>;
  <D.29772>:
  D.29774 = klass->interface_bitmap;
  D.29770 = klassc->interface_id;
  D.29775 = D.29770 >> 3;
  D.29776 = (sizetype) D.29775;
  D.29777 = D.29774 + D.29776;
  D.29778 = *D.29777;
  D.29779 = (int) D.29778;
  D.29770 = klassc->interface_id;
  D.29780 = (int) D.29770;
  D.29781 = D.29780 & 7;
  D.29782 = D.29779 >> D.29781;
  D.29783 = D.29782 & 1;
  if (D.29783 != 0) goto <D.29784>; else goto <D.29785>;
  <D.29784>:
  D.29786 = 1;
  return D.29786;
  <D.29785>:
  <D.29773>:
  goto <D.29757>;
  <D.29755>:
  if (check_interfaces != 0) goto <D.29791>; else goto <D.29787>;
  <D.29791>:
  D.29759 = klassc->flags;
  D.29760 = D.29759 & 32;
  if (D.29760 != 0) goto <D.29788>; else goto <D.29792>;
  <D.29792>:
  D.29762 = klassc->byval_arg.type;
  if (D.29762 == 19) goto <D.29788>; else goto <D.29793>;
  <D.29793>:
  D.29762 = klassc->byval_arg.type;
  if (D.29762 == 30) goto <D.29788>; else goto <D.29787>;
  <D.29788>:
  D.29764 = klass->flags;
  D.29765 = D.29764 & 32;
  if (D.29765 != 0) goto <D.29789>; else goto <D.29794>;
  <D.29794>:
  D.29767 = klass->byval_arg.type;
  if (D.29767 == 19) goto <D.29789>; else goto <D.29795>;
  <D.29795>:
  D.29767 = klass->byval_arg.type;
  if (D.29767 == 30) goto <D.29789>; else goto <D.29787>;
  <D.29789>:
  {
    int i;

    i = 0;
    goto <D.20956>;
    <D.20955>:
    {
      struct MonoClass * ic;

      D.29796 = klass->interfaces;
      i.405 = (unsigned int) i;
      D.29798 = i.405 * 4;
      D.29799 = D.29796 + D.29798;
      ic = *D.29799;
      if (ic == klassc) goto <D.29800>; else goto <D.29801>;
      <D.29800>:
      D.29786 = 1;
      return D.29786;
      <D.29801>:
    }
    i = i + 1;
    <D.20956>:
    D.29802 = klass->interface_count;
    D.29803 = (int) D.29802;
    if (D.29803 > i) goto <D.20955>; else goto <D.20957>;
    <D.20957>:
  }
  goto <D.29790>;
  <D.29787>:
  D.29764 = klass->flags;
  D.29765 = D.29764 & 32;
  if (D.29765 == 0) goto <D.29804>; else goto <D.29805>;
  <D.29804>:
  D.29767 = klass->byval_arg.type;
  if (D.29767 != 19) goto <D.29806>; else goto <D.29807>;
  <D.29806>:
  D.29767 = klass->byval_arg.type;
  if (D.29767 != 30) goto <D.29808>; else goto <D.29809>;
  <D.29808>:
  D.29810 = mono_class_has_parent (klass, klassc);
  if (D.29810 != 0) goto <D.29811>; else goto <D.29812>;
  <D.29811>:
  D.29786 = 1;
  return D.29786;
  <D.29812>:
  <D.29809>:
  <D.29807>:
  <D.29805>:
  <D.29790>:
  <D.29757>:
  D.29813 = mono_defaults.object_class;
  if (D.29813 == klassc) goto <D.29814>; else goto <D.29815>;
  <D.29814>:
  D.29786 = 1;
  return D.29786;
  <D.29815>:
  D.29786 = 0;
  return D.29786;
}


mono_class_has_parent (struct MonoClass * klass, struct MonoClass * parent)
{
  struct MonoClass * * D.29817;
  _Bool D.29818;
  long int D.29819;
  long int D.29820;
  struct MonoClass * * D.29823;
  _Bool D.29824;
  long int D.29825;
  long int D.29826;
  gboolean D.29829;

  D.29817 = klass->supertypes;
  D.29818 = D.29817 == 0B;
  D.29819 = (long int) D.29818;
  D.29820 = __builtin_expect (D.29819, 0);
  if (D.29820 != 0) goto <D.29821>; else goto <D.29822>;
  <D.29821>:
  mono_class_setup_supertypes (klass);
  <D.29822>:
  D.29823 = parent->supertypes;
  D.29824 = D.29823 == 0B;
  D.29825 = (long int) D.29824;
  D.29826 = __builtin_expect (D.29825, 0);
  if (D.29826 != 0) goto <D.29827>; else goto <D.29828>;
  <D.29827>:
  mono_class_setup_supertypes (parent);
  <D.29828>:
  D.29829 = mono_class_has_parent_fast (klass, parent);
  return D.29829;
}


mono_class_has_parent_fast (struct MonoClass * klass, struct MonoClass * parent)
{
  gboolean D.29831;
  int iftmp.406;
  short unsigned int D.29835;
  short unsigned int D.29836;
  struct MonoClass * * D.29838;
  sizetype D.29839;
  sizetype D.29840;
  sizetype D.29841;
  struct MonoClass * * D.29842;
  struct MonoClass * D.29843;

  D.29835 = klass->idepth;
  D.29836 = parent->idepth;
  if (D.29835 >= D.29836) goto <D.29837>; else goto <D.29833>;
  <D.29837>:
  D.29838 = klass->supertypes;
  D.29836 = parent->idepth;
  D.29839 = (sizetype) D.29836;
  D.29840 = D.29839 + 1073741823;
  D.29841 = D.29840 * 4;
  D.29842 = D.29838 + D.29841;
  D.29843 = *D.29842;
  if (D.29843 == parent) goto <D.29844>; else goto <D.29833>;
  <D.29844>:
  iftmp.406 = 1;
  goto <D.29834>;
  <D.29833>:
  iftmp.406 = 0;
  <D.29834>:
  D.29831 = iftmp.406;
  return D.29831;
}


mono_class_has_variant_generic_params (struct MonoClass * klass)
{
  struct MonoGenericClass * D.29846;
  gboolean D.29849;
  struct MonoClass * D.29850;
  struct MonoGenericParamFull * D.29851;
  unsigned int i.407;
  unsigned int D.29853;
  struct MonoGenericParamFull * D.29854;
  short unsigned int D.29855;
  int D.29856;
  int D.29857;
  <unnamed-signed:31> D.29860;
  int D.29861;
  int i;
  struct MonoGenericContainer * container;

  D.29846 = klass->generic_class;
  if (D.29846 == 0B) goto <D.29847>; else goto <D.29848>;
  <D.29847>:
  D.29849 = 0;
  return D.29849;
  <D.29848>:
  D.29846 = klass->generic_class;
  D.29850 = D.29846->container_class;
  container = D.29850->generic_container;
  i = 0;
  goto <D.20967>;
  <D.20966>:
  D.29851 = container->type_params;
  i.407 = (unsigned int) i;
  D.29853 = i.407 * 32;
  D.29854 = D.29851 + D.29853;
  D.29855 = D.29854->info.flags;
  D.29856 = (int) D.29855;
  D.29857 = D.29856 & 3;
  if (D.29857 != 0) goto <D.29858>; else goto <D.29859>;
  <D.29858>:
  D.29849 = 1;
  return D.29849;
  <D.29859>:
  i = i + 1;
  <D.20967>:
  D.29860 = container->type_argc;
  D.29861 = (int) D.29860;
  if (D.29861 > i) goto <D.20966>; else goto <D.20968>;
  <D.20968>:
  D.29849 = 0;
  return D.29849;
}


mono_class_is_variant_compatible (struct MonoClass * klass, struct MonoClass * oklass, gboolean check_for_reference_conv)
{
  gboolean D.29865;
  struct MonoClass * D.29868;
  struct MonoGenericClass * D.29870;
  struct MonoGenericInst * D.29871;
  struct MonoGenericClass * D.29872;
  struct MonoGenericInst * D.29873;
  unsigned int j.408;
  unsigned int D.29875;
  struct MonoType * * D.29876;
  struct MonoType * D.29877;
  struct MonoType * * D.29878;
  struct MonoType * D.29879;
  unsigned char D.29882;
  unsigned char D.29883;
  unsigned char D.29884;
  unsigned char D.29885;
  unsigned char D.29887;
  struct MonoGenericParamFull * D.29891;
  unsigned int D.29892;
  struct MonoGenericParamFull * D.29893;
  short unsigned int D.29894;
  int D.29895;
  int D.29896;
  int D.29899;
  int D.29903;
  int D.29906;
  <unnamed-signed:31> D.29910;
  int D.29911;
  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.29863>; else goto <D.29864>;
  <D.29863>:
  D.29865 = 1;
  return D.29865;
  <D.29864>:
  D.29868 = mono_class_get_generic_type_definition (oklass);
  if (D.29868 != klass_gtd) goto <D.29866>; else goto <D.29869>;
  <D.29869>:
  if (oklass == klass_gtd) goto <D.29866>; else goto <D.29867>;
  <D.29866>:
  D.29865 = 0;
  return D.29865;
  <D.29867>:
  D.29870 = klass->generic_class;
  D.29871 = D.29870->context.class_inst;
  klass_argv = &D.29871->type_argv[0];
  D.29872 = oklass->generic_class;
  D.29873 = D.29872->context.class_inst;
  oklass_argv = &D.29873->type_argv[0];
  j = 0;
  goto <D.20989>;
  <D.20988>:
  {
    struct MonoClass * param1_class;
    struct MonoClass * param2_class;

    j.408 = (unsigned int) j;
    D.29875 = j.408 * 4;
    D.29876 = klass_argv + D.29875;
    D.29877 = *D.29876;
    param1_class = mono_class_from_mono_type (D.29877);
    j.408 = (unsigned int) j;
    D.29875 = j.408 * 4;
    D.29878 = oklass_argv + D.29875;
    D.29879 = *D.29878;
    param2_class = mono_class_from_mono_type (D.29879);
    D.29882 = BIT_FIELD_REF <*param1_class, 8, 160>;
    D.29883 = BIT_FIELD_REF <*param2_class, 8, 160>;
    D.29884 = D.29882 ^ D.29883;
    D.29885 = D.29884 & 8;
    if (D.29885 != 0) goto <D.29880>; else goto <D.29886>;
    <D.29886>:
    D.29882 = BIT_FIELD_REF <*param1_class, 8, 160>;
    D.29887 = D.29882 & 8;
    if (D.29887 != 0) goto <D.29888>; else goto <D.29881>;
    <D.29888>:
    if (param1_class != param2_class) goto <D.29880>; else goto <D.29881>;
    <D.29880>:
    D.29865 = 0;
    return D.29865;
    <D.29881>:
    if (param1_class != param2_class) goto <D.29889>; else goto <D.29890>;
    <D.29889>:
    D.29891 = container->type_params;
    j.408 = (unsigned int) j;
    D.29892 = j.408 * 32;
    D.29893 = D.29891 + D.29892;
    D.29894 = D.29893->info.flags;
    D.29895 = (int) D.29894;
    D.29896 = D.29895 & 1;
    if (D.29896 != 0) goto <D.29897>; else goto <D.29898>;
    <D.29897>:
    D.29899 = mono_gparam_is_reference_conversible (param1_class, param2_class, check_for_reference_conv);
    if (D.29899 == 0) goto <D.29900>; else goto <D.29901>;
    <D.29900>:
    D.29865 = 0;
    return D.29865;
    <D.29901>:
    goto <D.29902>;
    <D.29898>:
    D.29891 = container->type_params;
    j.408 = (unsigned int) j;
    D.29892 = j.408 * 32;
    D.29893 = D.29891 + D.29892;
    D.29894 = D.29893->info.flags;
    D.29895 = (int) D.29894;
    D.29903 = D.29895 & 2;
    if (D.29903 != 0) goto <D.29904>; else goto <D.29905>;
    <D.29904>:
    D.29906 = mono_gparam_is_reference_conversible (param2_class, param1_class, check_for_reference_conv);
    if (D.29906 == 0) goto <D.29907>; else goto <D.29908>;
    <D.29907>:
    D.29865 = 0;
    return D.29865;
    <D.29908>:
    goto <D.29909>;
    <D.29905>:
    D.29865 = 0;
    return D.29865;
    <D.29909>:
    <D.29902>:
    <D.29890>:
  }
  j = j + 1;
  <D.20989>:
  D.29910 = container->type_argc;
  D.29911 = (int) D.29910;
  if (D.29911 > j) goto <D.20988>; else goto <D.20990>;
  <D.20990>:
  D.29865 = 1;
  return D.29865;
}


mono_gparam_is_reference_conversible (struct MonoClass * target, struct MonoClass * candidate, gboolean check_for_reference_conv)
{
  gboolean D.29915;
  struct MonoType * D.29918;
  int D.29919;
  struct MonoType * D.29922;
  int D.29923;
  struct MonoGenericParamInfo * iftmp.409;
  struct MonoGenericContainer * D.29927;
  short unsigned int D.29934;
  int D.29935;
  int D.29936;
  int D.29937;

  if (target == candidate) goto <D.29913>; else goto <D.29914>;
  <D.29913>:
  D.29915 = 1;
  return D.29915;
  <D.29914>:
  if (check_for_reference_conv != 0) goto <D.29916>; else goto <D.29917>;
  <D.29916>:
  D.29918 = &target->byval_arg;
  D.29919 = mono_type_is_generic_argument (D.29918);
  if (D.29919 != 0) goto <D.29920>; else goto <D.29921>;
  <D.29920>:
  D.29922 = &candidate->byval_arg;
  D.29923 = mono_type_is_generic_argument (D.29922);
  if (D.29923 != 0) goto <D.29924>; else goto <D.29925>;
  <D.29924>:
  {
    struct MonoGenericParam * gparam;
    struct MonoGenericParamInfo * pinfo;

    gparam = candidate->byval_arg.data.generic_param;
    D.29927 = gparam->owner;
    if (D.29927 != 0B) goto <D.29928>; else goto <D.29929>;
    <D.29928>:
    iftmp.409 = &MEM[(struct MonoGenericParamFull *)gparam].info;
    goto <D.29930>;
    <D.29929>:
    iftmp.409 = 0B;
    <D.29930>:
    pinfo = iftmp.409;
    if (pinfo == 0B) goto <D.29931>; else goto <D.29933>;
    <D.29933>:
    D.29934 = pinfo->flags;
    D.29935 = (int) D.29934;
    D.29936 = D.29935 & 4;
    if (D.29936 == 0) goto <D.29931>; else goto <D.29932>;
    <D.29931>:
    D.29915 = 0;
    return D.29915;
    <D.29932>:
  }
  <D.29925>:
  <D.29921>:
  <D.29917>:
  D.29937 = mono_class_is_assignable_from (target, candidate);
  if (D.29937 == 0) goto <D.29938>; else goto <D.29939>;
  <D.29938>:
  D.29915 = 0;
  return D.29915;
  <D.29939>:
  D.29915 = 1;
  return D.29915;
}


mono_type_is_generic_argument (struct MonoType * type)
{
  gboolean D.29941;
  unsigned char D.29942;
  _Bool D.29943;
  _Bool D.29944;
  _Bool D.29945;

  D.29942 = type->type;
  D.29943 = D.29942 == 19;
  D.29944 = D.29942 == 30;
  D.29945 = D.29943 | D.29944;
  D.29941 = (gboolean) D.29945;
  return D.29941;
}


mono_class_is_assignable_from (struct MonoClass * klass, struct MonoClass * oklass)
{
  unsigned char D.29947;
  unsigned char D.29948;
  unsigned char D.29951;
  unsigned char D.29952;
  unsigned char D.29957;
  unsigned char D.29959;
  mono_bool D.29960;
  struct MonoType * D.29961;
  int D.29962;
  struct MonoType * D.29965;
  int D.29966;
  unsigned int D.29971;
  unsigned int D.29972;
  unsigned char D.29974;
  unsigned char D.29976;
  _Bool D.29977;
  _Bool D.29978;
  _Bool D.29979;
  struct MonoGenericContainer * D.29982;
  struct MonoGenericParamFull * D.29983;
  short unsigned int D.29984;
  unsigned int D.29985;
  unsigned int D.29986;
  struct MonoGenericParamFull * D.29987;
  unsigned int i.410;
  unsigned int D.29991;
  struct MonoClass * * D.29992;
  struct MonoClass * D.29993;
  int D.29994;
  unsigned int D.29997;
  guint8 * D.30000;
  short unsigned int D.30005;
  short unsigned int D.30006;
  short unsigned int D.30009;
  sizetype D.30010;
  guint8 * D.30011;
  unsigned char D.30012;
  int D.30013;
  int D.30014;
  int D.30015;
  int D.30016;
  int D.30017;
  int D.30020;
  int D.30023;
  struct MonoClass * * D.30026;
  unsigned int i.411;
  unsigned int D.30028;
  struct MonoClass * * D.30029;
  int D.30030;
  short unsigned int D.30033;
  int D.30034;
  unsigned char D.30035;
  unsigned char D.30036;
  int D.30039;
  int D.30042;
  unsigned char D.30046;
  unsigned char D.30049;
  unsigned char D.30052;
  unsigned char D.30055;
  unsigned char D.30056;
  struct MonoClass * D.30061;
  struct MonoClass * D.30063;
  struct MonoClass * D.30065;
  struct MonoClass * D.30066;
  struct MonoClass * D.30067;
  int D.30068;
  int D.30071;

  D.29947 = BIT_FIELD_REF <*klass, 8, 160>;
  D.29948 = D.29947 & 1;
  if (D.29948 == 0) goto <D.29949>; else goto <D.29950>;
  <D.29949>:
  mono_class_init (klass);
  <D.29950>:
  D.29951 = BIT_FIELD_REF <*oklass, 8, 160>;
  D.29952 = D.29951 & 1;
  if (D.29952 == 0) goto <D.29953>; else goto <D.29954>;
  <D.29953>:
  mono_class_init (oklass);
  <D.29954>:
  D.29957 = klass->exception_type;
  if (D.29957 != 0) goto <D.29955>; else goto <D.29958>;
  <D.29958>:
  D.29959 = oklass->exception_type;
  if (D.29959 != 0) goto <D.29955>; else goto <D.29956>;
  <D.29955>:
  D.29960 = 0;
  return D.29960;
  <D.29956>:
  D.29961 = &klass->byval_arg;
  D.29962 = mono_type_is_generic_argument (D.29961);
  if (D.29962 != 0) goto <D.29963>; else goto <D.29964>;
  <D.29963>:
  D.29965 = &oklass->byval_arg;
  D.29966 = mono_type_is_generic_argument (D.29965);
  if (D.29966 == 0) goto <D.29967>; else goto <D.29968>;
  <D.29967>:
  D.29960 = 0;
  return D.29960;
  <D.29968>:
  D.29960 = mono_gparam_is_assignable_from (klass, oklass);
  return D.29960;
  <D.29964>:
  D.29971 = klass->flags;
  D.29972 = D.29971 & 32;
  if (D.29972 != 0) goto <D.29969>; else goto <D.29973>;
  <D.29973>:
  D.29974 = klass->byval_arg.type;
  if (D.29974 == 19) goto <D.29969>; else goto <D.29975>;
  <D.29975>:
  D.29974 = klass->byval_arg.type;
  if (D.29974 == 30) goto <D.29969>; else goto <D.29970>;
  <D.29969>:
  D.29976 = oklass->byval_arg.type;
  D.29977 = D.29976 == 19;
  D.29978 = D.29976 == 30;
  D.29979 = D.29977 | D.29978;
  if (D.29979 != 0) goto <D.29980>; else goto <D.29981>;
  <D.29980>:
  {
    struct MonoGenericParam * gparam;
    struct MonoClass * * constraints;
    int i;

    gparam = oklass->byval_arg.data.generic_param;
    D.29982 = gparam->owner;
    D.29983 = D.29982->type_params;
    D.29984 = gparam->num;
    D.29985 = (unsigned int) D.29984;
    D.29986 = D.29985 * 32;
    D.29987 = D.29983 + D.29986;
    constraints = D.29987->info.constraints;
    if (constraints != 0B) goto <D.29988>; else goto <D.29989>;
    <D.29988>:
    i = 0;
    goto <D.21030>;
    <D.21029>:
    i.410 = (unsigned int) i;
    D.29991 = i.410 * 4;
    D.29992 = constraints + D.29991;
    D.29993 = *D.29992;
    D.29994 = mono_class_is_assignable_from (klass, D.29993);
    if (D.29994 != 0) goto <D.29995>; else goto <D.29996>;
    <D.29995>:
    D.29960 = 1;
    return D.29960;
    <D.29996>:
    i = i + 1;
    <D.21030>:
    i.410 = (unsigned int) i;
    D.29991 = i.410 * 4;
    D.29992 = constraints + D.29991;
    D.29993 = *D.29992;
    if (D.29993 != 0B) goto <D.21029>; else goto <D.21031>;
    <D.21031>:
    <D.29989>:
    D.29960 = 0;
    return D.29960;
  }
  <D.29981>:
  D.29997 = oklass->ref_info_handle;
  if (D.29997 != 0) goto <D.29998>; else goto <D.29999>;
  <D.29998>:
  D.30000 = oklass->interface_bitmap;
  if (D.30000 == 0B) goto <D.30001>; else goto <D.30002>;
  <D.30001>:
  D.29960 = mono_reflection_call_is_assignable_to (oklass, klass);
  return D.29960;
  <D.30002>:
  <D.29999>:
  D.30000 = oklass->interface_bitmap;
  if (D.30000 == 0B) goto <D.30003>; else goto <D.30004>;
  <D.30003>:
  D.29960 = 0;
  return D.29960;
  <D.30004>:
  D.30005 = klass->interface_id;
  D.30006 = oklass->max_interface_id;
  if (D.30005 <= D.30006) goto <D.30007>; else goto <D.30008>;
  <D.30007>:
  D.30000 = oklass->interface_bitmap;
  D.30005 = klass->interface_id;
  D.30009 = D.30005 >> 3;
  D.30010 = (sizetype) D.30009;
  D.30011 = D.30000 + D.30010;
  D.30012 = *D.30011;
  D.30013 = (int) D.30012;
  D.30005 = klass->interface_id;
  D.30014 = (int) D.30005;
  D.30015 = D.30014 & 7;
  D.30016 = D.30013 >> D.30015;
  D.30017 = D.30016 & 1;
  if (D.30017 != 0) goto <D.30018>; else goto <D.30019>;
  <D.30018>:
  D.29960 = 1;
  return D.29960;
  <D.30019>:
  <D.30008>:
  D.30020 = mono_class_has_variant_generic_params (klass);
  if (D.30020 != 0) goto <D.30021>; else goto <D.30022>;
  <D.30021>:
  {
    struct MonoError error;
    int i;

    try
      {
        mono_class_setup_interfaces (oklass, &error);
        D.30023 = mono_error_ok (&error);
        if (D.30023 == 0) goto <D.30024>; else goto <D.30025>;
        <D.30024>:
        mono_error_cleanup (&error);
        D.29960 = 0;
        return D.29960;
        <D.30025>:
        i = 0;
        goto <D.21036>;
        <D.21035>:
        {
          struct MonoClass * iface;

          D.30026 = oklass->interfaces_packed;
          i.411 = (unsigned int) i;
          D.30028 = i.411 * 4;
          D.30029 = D.30026 + D.30028;
          iface = *D.30029;
          D.30030 = mono_class_is_variant_compatible (klass, iface, 0);
          if (D.30030 != 0) goto <D.30031>; else goto <D.30032>;
          <D.30031>:
          D.29960 = 1;
          return D.29960;
          <D.30032>:
        }
        i = i + 1;
        <D.21036>:
        D.30033 = oklass->interface_offsets_count;
        D.30034 = (int) D.30033;
        if (D.30034 > i) goto <D.21035>; else goto <D.21037>;
        <D.21037>:
      }
    finally
      {
        error = {CLOBBER};
      }
  }
  <D.30022>:
  D.29960 = 0;
  return D.29960;
  <D.29970>:
  D.30035 = BIT_FIELD_REF <*klass, 8, 184>;
  D.30036 = D.30035 & 1;
  if (D.30036 != 0) goto <D.30037>; else goto <D.30038>;
  <D.30037>:
  D.30039 = mono_class_has_variant_generic_params (klass);
  if (D.30039 != 0) goto <D.30040>; else goto <D.30041>;
  <D.30040>:
  D.30042 = mono_class_is_variant_compatible (klass, oklass, 0);
  if (D.30042 != 0) goto <D.30043>; else goto <D.30044>;
  <D.30043>:
  D.29960 = 1;
  return D.29960;
  <D.30044>:
  <D.30041>:
  goto <D.30045>;
  <D.30038>:
  D.30046 = klass->rank;
  if (D.30046 != 0) goto <D.30047>; else goto <D.30048>;
  <D.30047>:
  {
    struct MonoClass * eclass;
    struct MonoClass * eoclass;

    D.30049 = oklass->rank;
    D.30046 = klass->rank;
    if (D.30049 != D.30046) goto <D.30050>; else goto <D.30051>;
    <D.30050>:
    D.29960 = 0;
    return D.29960;
    <D.30051>:
    D.30052 = oklass->byval_arg.type;
    D.29974 = klass->byval_arg.type;
    if (D.30052 != D.29974) goto <D.30053>; else goto <D.30054>;
    <D.30053>:
    D.29960 = 0;
    return D.29960;
    <D.30054>:
    eclass = klass->cast_class;
    eoclass = oklass->cast_class;
    D.30055 = BIT_FIELD_REF <*eoclass, 8, 160>;
    D.30056 = D.30055 & 8;
    if (D.30056 != 0) goto <D.30057>; else goto <D.30058>;
    <D.30057>:
    D.30061 = mono_defaults.enum_class;
    if (D.30061 == eclass) goto <D.30059>; else goto <D.30062>;
    <D.30062>:
    D.30061 = mono_defaults.enum_class;
    D.30063 = D.30061->parent;
    if (D.30063 == eclass) goto <D.30059>; else goto <D.30064>;
    <D.30064>:
    D.30065 = mono_defaults.object_class;
    if (D.30065 == eclass) goto <D.30059>; else goto <D.30060>;
    <D.30059>:
    D.29960 = 0;
    return D.29960;
    <D.30060>:
    <D.30058>:
    D.30066 = oklass->cast_class;
    D.30067 = klass->cast_class;
    D.29960 = mono_class_is_assignable_from (D.30067, D.30066);
    return D.29960;
  }
  <D.30048>:
  D.30068 = mono_class_is_nullable (klass);
  if (D.30068 != 0) goto <D.30069>; else goto <D.30070>;
  <D.30069>:
  D.30071 = mono_class_is_nullable (oklass);
  if (D.30071 != 0) goto <D.30072>; else goto <D.30073>;
  <D.30072>:
  D.30066 = oklass->cast_class;
  D.30067 = klass->cast_class;
  D.29960 = mono_class_is_assignable_from (D.30067, D.30066);
  return D.29960;
  <D.30073>:
  D.30067 = klass->cast_class;
  D.29960 = mono_class_is_assignable_from (D.30067, oklass);
  return D.29960;
  <D.30070>:
  D.30065 = mono_defaults.object_class;
  if (D.30065 == klass) goto <D.30074>; else goto <D.30075>;
  <D.30074>:
  D.29960 = 1;
  return D.29960;
  <D.30075>:
  <D.30045>:
  D.29960 = mono_class_has_parent (oklass, klass);
  return D.29960;
}


mono_gparam_is_assignable_from (struct MonoClass * target, struct MonoClass * candidate)
{
  gboolean D.30081;
  unsigned char D.30082;
  unsigned char D.30083;
  struct MonoGenericParamInfo * iftmp.412;
  struct MonoGenericContainer * D.30087;
  struct MonoGenericParamInfo * iftmp.413;
  struct MonoGenericContainer * D.30092;
  short unsigned int D.30096;
  int D.30097;
  short unsigned int D.30098;
  int D.30099;
  struct MonoClass * * D.30100;
  struct MonoType * D.30105;
  int D.30106;
  unsigned int D.30108;
  unsigned int D.30109;
  unsigned char D.30111;
  int D.30114;
  struct MonoClass * D.30123;
  int D.30124;
  _Bool D.30125;
  int D.30126;
  int D.30127;
  _Bool D.30128;
  int D.30129;
  int D.30130;
  int D.30135;
  int D.30140;
  int D.30143;
  int D.30144;
  struct MonoClass * * D.30147;
  struct MonoType * D.30150;
  struct MonoType * D.30151;
  int D.30152;
  int D.30157;
  struct MonoType * D.30159;
  int D.30160;
  int D.30163;
  struct MonoClass * D.30167;
  int D.30170;
  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.30079>; else goto <D.30080>;
  <D.30079>:
  D.30081 = 1;
  return D.30081;
  <D.30080>:
  D.30082 = target->byval_arg.type;
  D.30083 = candidate->byval_arg.type;
  if (D.30082 != D.30083) goto <D.30084>; else goto <D.30085>;
  <D.30084>:
  D.30081 = 0;
  return D.30081;
  <D.30085>:
  gparam = target->byval_arg.data.generic_param;
  ogparam = candidate->byval_arg.data.generic_param;
  D.30087 = gparam->owner;
  if (D.30087 != 0B) goto <D.30088>; else goto <D.30089>;
  <D.30088>:
  iftmp.412 = &MEM[(struct MonoGenericParamFull *)gparam].info;
  goto <D.30090>;
  <D.30089>:
  iftmp.412 = 0B;
  <D.30090>:
  tinfo = iftmp.412;
  D.30092 = ogparam->owner;
  if (D.30092 != 0B) goto <D.30093>; else goto <D.30094>;
  <D.30093>:
  iftmp.413 = &MEM[(struct MonoGenericParamFull *)ogparam].info;
  goto <D.30095>;
  <D.30094>:
  iftmp.413 = 0B;
  <D.30095>:
  cinfo = iftmp.413;
  class_constraint_satisfied = 0;
  valuetype_constraint_satisfied = 0;
  D.30096 = tinfo->flags;
  D.30097 = (int) D.30096;
  tmask = D.30097 & 28;
  D.30098 = cinfo->flags;
  D.30099 = (int) D.30098;
  cmask = D.30099 & 28;
  D.30100 = cinfo->constraints;
  if (D.30100 != 0B) goto <D.30101>; else goto <D.30102>;
  <D.30101>:
  candidate_class = cinfo->constraints;
  goto <D.21006>;
  <D.21005>:
  {
    struct MonoClass * cc;

    cc = *candidate_class;
    D.30105 = &cc->byval_arg;
    D.30106 = mono_type_is_reference (D.30105);
    if (D.30106 != 0) goto <D.30107>; else goto <D.30103>;
    <D.30107>:
    D.30108 = cc->flags;
    D.30109 = D.30108 & 32;
    if (D.30109 == 0) goto <D.30110>; else goto <D.30103>;
    <D.30110>:
    D.30111 = cc->byval_arg.type;
    if (D.30111 != 19) goto <D.30112>; else goto <D.30103>;
    <D.30112>:
    D.30111 = cc->byval_arg.type;
    if (D.30111 != 30) goto <D.30113>; else goto <D.30103>;
    <D.30113>:
    class_constraint_satisfied = 1;
    goto <D.30104>;
    <D.30103>:
    D.30105 = &cc->byval_arg;
    D.30114 = mono_type_is_reference (D.30105);
    if (D.30114 == 0) goto <D.30115>; else goto <D.30116>;
    <D.30115>:
    D.30108 = cc->flags;
    D.30109 = D.30108 & 32;
    if (D.30109 == 0) goto <D.30117>; else goto <D.30118>;
    <D.30117>:
    D.30111 = cc->byval_arg.type;
    if (D.30111 != 19) goto <D.30119>; else goto <D.30120>;
    <D.30119>:
    D.30111 = cc->byval_arg.type;
    if (D.30111 != 30) goto <D.30121>; else goto <D.30122>;
    <D.30121>:
    valuetype_constraint_satisfied = 1;
    <D.30122>:
    <D.30120>:
    <D.30118>:
    <D.30116>:
    <D.30104>:
  }
  candidate_class = candidate_class + 4;
  <D.21006>:
  D.30123 = *candidate_class;
  if (D.30123 != 0B) goto <D.21005>; else goto <D.21007>;
  <D.21007>:
  <D.30102>:
  D.30124 = cmask & 4;
  D.30125 = D.30124 != 0;
  D.30126 = (int) D.30125;
  class_constraint_satisfied = D.30126 | class_constraint_satisfied;
  D.30127 = cmask & 8;
  D.30128 = D.30127 != 0;
  D.30129 = (int) D.30128;
  valuetype_constraint_satisfied = D.30129 | valuetype_constraint_satisfied;
  D.30130 = tmask & 4;
  if (D.30130 != 0) goto <D.30131>; else goto <D.30132>;
  <D.30131>:
  if (class_constraint_satisfied == 0) goto <D.30133>; else goto <D.30134>;
  <D.30133>:
  D.30081 = 0;
  return D.30081;
  <D.30134>:
  <D.30132>:
  D.30135 = tmask & 8;
  if (D.30135 != 0) goto <D.30136>; else goto <D.30137>;
  <D.30136>:
  if (valuetype_constraint_satisfied == 0) goto <D.30138>; else goto <D.30139>;
  <D.30138>:
  D.30081 = 0;
  return D.30081;
  <D.30139>:
  <D.30137>:
  D.30140 = tmask & 16;
  if (D.30140 != 0) goto <D.30141>; else goto <D.30142>;
  <D.30141>:
  D.30143 = cmask & 16;
  D.30144 = D.30143 | valuetype_constraint_satisfied;
  if (D.30144 == 0) goto <D.30145>; else goto <D.30146>;
  <D.30145>:
  D.30081 = 0;
  return D.30081;
  <D.30146>:
  <D.30142>:
  D.30147 = tinfo->constraints;
  if (D.30147 != 0B) goto <D.30148>; else goto <D.30149>;
  <D.30148>:
  {
    struct MonoClass * * target_class;

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

      tc = *target_class;
      D.30150 = &candidate->byval_arg;
      D.30151 = &tc->byval_arg;
      D.30152 = mono_metadata_type_equal (D.30151, D.30150);
      if (D.30152 != 0) goto <D.30153>; else goto <D.30154>;
      <D.30153>:
      // predicted unlikely by continue predictor.
      goto <D.21010>;
      <D.30154>:
      D.30100 = cinfo->constraints;
      if (D.30100 == 0B) goto <D.30155>; else goto <D.30156>;
      <D.30155>:
      D.30081 = 0;
      return D.30081;
      <D.30156>:
      candidate_class = cinfo->constraints;
      goto <D.21014>;
      <D.21013>:
      {
        struct MonoClass * cc;

        cc = *candidate_class;
        D.30157 = mono_class_is_assignable_from (tc, cc);
        if (D.30157 != 0) goto <D.21012>; else goto <D.30158>;
        <D.30158>:
        D.30159 = &cc->byval_arg;
        D.30160 = mono_type_is_generic_argument (D.30159);
        if (D.30160 != 0) goto <D.30161>; else goto <D.30162>;
        <D.30161>:
        D.30163 = mono_gparam_is_assignable_from (target, cc);
        if (D.30163 != 0) goto <D.21012>; else goto <D.30164>;
        <D.30164>:
        <D.30162>:
      }
      candidate_class = candidate_class + 4;
      <D.21014>:
      D.30123 = *candidate_class;
      if (D.30123 != 0B) goto <D.21013>; else goto <D.21012>;
      <D.21012>:
      D.30123 = *candidate_class;
      if (D.30123 == 0B) goto <D.30165>; else goto <D.30166>;
      <D.30165>:
      D.30081 = 0;
      return D.30081;
      <D.30166>:
    }
    <D.21010>:
    target_class = target_class + 4;
    <D.21016>:
    D.30167 = *target_class;
    if (D.30167 != 0B) goto <D.21015>; else goto <D.21017>;
    <D.21017>:
  }
  <D.30149>:
  D.30100 = cinfo->constraints;
  if (D.30100 != 0B) goto <D.30168>; else goto <D.30169>;
  <D.30168>:
  candidate_class = cinfo->constraints;
  goto <D.21020>;
  <D.21019>:
  {
    struct MonoClass * cc;

    cc = *candidate_class;
    D.30170 = mono_class_is_assignable_from (target, cc);
    if (D.30170 != 0) goto <D.30171>; else goto <D.30172>;
    <D.30171>:
    D.30081 = 1;
    return D.30081;
    <D.30172>:
  }
  candidate_class = candidate_class + 4;
  <D.21020>:
  D.30123 = *candidate_class;
  if (D.30123 != 0B) goto <D.21019>; else goto <D.21021>;
  <D.21021>:
  <D.30169>:
  D.30081 = 0;
  return D.30081;
}


mono_class_is_assignable_from_slow (struct MonoClass * target, struct MonoClass * candidate)
{
  gboolean D.30176;
  struct MonoClass * D.30177;
  int D.30180;
  unsigned int D.30185;
  unsigned int D.30186;
  unsigned char D.30188;
  unsigned char D.30190;
  unsigned char D.30191;
  int D.30194;
  unsigned char D.30197;
  unsigned char D.30200;
  unsigned char D.30203;
  unsigned char D.30206;
  unsigned char D.30207;
  struct MonoClass * D.30212;
  struct MonoClass * D.30214;
  struct MonoClass * D.30216;
  struct MonoClass * D.30217;

  if (candidate == target) goto <D.30174>; else goto <D.30175>;
  <D.30174>:
  D.30176 = 1;
  return D.30176;
  <D.30175>:
  D.30177 = mono_defaults.object_class;
  if (D.30177 == target) goto <D.30178>; else goto <D.30179>;
  <D.30178>:
  D.30176 = 1;
  return D.30176;
  <D.30179>:
  D.30180 = mono_class_has_parent (candidate, target);
  if (D.30180 != 0) goto <D.30181>; else goto <D.30182>;
  <D.30181>:
  D.30176 = 1;
  return D.30176;
  <D.30182>:
  D.30185 = target->flags;
  D.30186 = D.30185 & 32;
  if (D.30186 != 0) goto <D.30183>; else goto <D.30187>;
  <D.30187>:
  D.30188 = target->byval_arg.type;
  if (D.30188 == 19) goto <D.30183>; else goto <D.30189>;
  <D.30189>:
  D.30188 = target->byval_arg.type;
  if (D.30188 == 30) goto <D.30183>; else goto <D.30184>;
  <D.30183>:
  D.30176 = mono_class_implement_interface_slow (target, candidate);
  return D.30176;
  <D.30184>:
  D.30190 = BIT_FIELD_REF <*target, 8, 184>;
  D.30191 = D.30190 & 1;
  if (D.30191 != 0) goto <D.30192>; else goto <D.30193>;
  <D.30192>:
  D.30194 = mono_class_has_variant_generic_params (target);
  if (D.30194 != 0) goto <D.30195>; else goto <D.30196>;
  <D.30195>:
  D.30176 = mono_class_is_variant_compatible (target, candidate, 0);
  return D.30176;
  <D.30196>:
  <D.30193>:
  D.30197 = target->rank;
  if (D.30197 != 0) goto <D.30198>; else goto <D.30199>;
  <D.30198>:
  {
    struct MonoClass * eclass;
    struct MonoClass * eoclass;

    D.30197 = target->rank;
    D.30200 = candidate->rank;
    if (D.30197 != D.30200) goto <D.30201>; else goto <D.30202>;
    <D.30201>:
    D.30176 = 0;
    return D.30176;
    <D.30202>:
    D.30188 = target->byval_arg.type;
    D.30203 = candidate->byval_arg.type;
    if (D.30188 != D.30203) goto <D.30204>; else goto <D.30205>;
    <D.30204>:
    D.30176 = 0;
    return D.30176;
    <D.30205>:
    eclass = target->cast_class;
    eoclass = candidate->cast_class;
    D.30206 = BIT_FIELD_REF <*eoclass, 8, 160>;
    D.30207 = D.30206 & 8;
    if (D.30207 != 0) goto <D.30208>; else goto <D.30209>;
    <D.30208>:
    D.30212 = mono_defaults.enum_class;
    if (D.30212 == eclass) goto <D.30210>; else goto <D.30213>;
    <D.30213>:
    D.30212 = mono_defaults.enum_class;
    D.30214 = D.30212->parent;
    if (D.30214 == eclass) goto <D.30210>; else goto <D.30215>;
    <D.30215>:
    D.30177 = mono_defaults.object_class;
    if (D.30177 == eclass) goto <D.30210>; else goto <D.30211>;
    <D.30210>:
    D.30176 = 0;
    return D.30176;
    <D.30211>:
    <D.30209>:
    D.30216 = candidate->cast_class;
    D.30217 = target->cast_class;
    D.30176 = mono_class_is_assignable_from_slow (D.30217, D.30216);
    return D.30176;
  }
  <D.30199>:
  D.30176 = 0;
  return D.30176;
}


mono_class_implement_interface_slow (struct MonoClass * target, struct MonoClass * candidate)
{
  unsigned int D.30223;
  unsigned int D.30224;
  unsigned char D.30226;
  int D.30228;
  gboolean D.30231;
  struct MonoImage * D.30235;
  unsigned char D.30236;
  unsigned char D.30237;
  unsigned char D.30239;
  unsigned char D.30240;
  struct MonoArray * D.30244;
  unsigned int D.30247;
  unsigned int D.30248;
  unsigned int j.414;
  char * D.30250;
  struct MonoType * D.30251;
  int D.30258;
  int D.30261;
  int D.30264;
  struct MonoClass * * D.30267;
  unsigned int i.415;
  unsigned int D.30269;
  struct MonoClass * * D.30270;
  struct MonoClass * D.30271;
  int D.30276;
  int D.30279;
  short unsigned int D.30282;
  int D.30283;
  struct MonoError error;
  int i;
  gboolean is_variant;

  try
    {
      is_variant = mono_class_has_variant_generic_params (target);
      if (is_variant != 0) goto <D.30221>; else goto <D.30222>;
      <D.30221>:
      D.30223 = candidate->flags;
      D.30224 = D.30223 & 32;
      if (D.30224 != 0) goto <D.30219>; else goto <D.30225>;
      <D.30225>:
      D.30226 = candidate->byval_arg.type;
      if (D.30226 == 19) goto <D.30219>; else goto <D.30227>;
      <D.30227>:
      D.30226 = candidate->byval_arg.type;
      if (D.30226 == 30) goto <D.30219>; else goto <D.30220>;
      <D.30219>:
      D.30228 = mono_class_is_variant_compatible_slow (target, candidate);
      if (D.30228 != 0) goto <D.30229>; else goto <D.30230>;
      <D.30229>:
      D.30231 = 1;
      return D.30231;
      <D.30230>:
      <D.30220>:
      <D.30222>:
      <D.21072>:
      if (candidate == target) goto <D.30232>; else goto <D.30233>;
      <D.30232>:
      D.30231 = 1;
      return D.30231;
      <D.30233>:
      D.30235 = candidate->image;
      D.30236 = BIT_FIELD_REF <*D.30235, 8, 128>;
      D.30237 = D.30236 & 8;
      if (D.30237 != 0) goto <D.30238>; else goto <D.30234>;
      <D.30238>:
      D.30239 = BIT_FIELD_REF <*candidate, 8, 160>;
      D.30240 = D.30239 & 128;
      if (D.30240 == 0) goto <D.30241>; else goto <D.30234>;
      <D.30241>:
      {
        struct MonoReflectionTypeBuilder * tb;
        int j;

        tb = mono_class_get_ref_info (candidate);
        if (tb != 0B) goto <D.30242>; else goto <D.30243>;
        <D.30242>:
        D.30244 = tb->interfaces;
        if (D.30244 != 0B) goto <D.30245>; else goto <D.30246>;
        <D.30245>:
        D.30244 = tb->interfaces;
        D.30247 = mono_array_length (D.30244);
        D.30248 = D.30247 + 4294967295;
        j = (int) D.30248;
        goto <D.21067>;
        <D.21066>:
        {
          struct MonoReflectionType * iface;
          struct MonoClass * iface_class;

          j.414 = (unsigned int) j;
          D.30244 = tb->interfaces;
          D.30250 = mono_array_addr_with_size (D.30244, 4, j.414);
          iface = MEM[(struct MonoReflectionType * *)D.30250];
          D.30251 = iface->type;
          if (D.30251 == 0B) goto <D.30252>; else goto <D.30253>;
          <D.30252>:
          // predicted unlikely by continue predictor.
          goto <D.21065>;
          <D.30253>:
          D.30251 = iface->type;
          iface_class = mono_class_from_mono_type (D.30251);
          if (iface_class == target) goto <D.30254>; else goto <D.30255>;
          <D.30254>:
          D.30231 = 1;
          return D.30231;
          <D.30255>:
          if (is_variant != 0) goto <D.30256>; else goto <D.30257>;
          <D.30256>:
          D.30258 = mono_class_is_variant_compatible_slow (target, iface_class);
          if (D.30258 != 0) goto <D.30259>; else goto <D.30260>;
          <D.30259>:
          D.30231 = 1;
          return D.30231;
          <D.30260>:
          <D.30257>:
          D.30261 = mono_class_implement_interface_slow (target, iface_class);
          if (D.30261 != 0) goto <D.30262>; else goto <D.30263>;
          <D.30262>:
          D.30231 = 1;
          return D.30231;
          <D.30263>:
        }
        <D.21065>:
        j = j + -1;
        <D.21067>:
        if (j >= 0) goto <D.21066>; else goto <D.21068>;
        <D.21068>:
        <D.30246>:
        <D.30243>:
      }
      goto <D.21071>;
      <D.30234>:
      mono_class_setup_interfaces (candidate, &error);
      D.30264 = mono_error_ok (&error);
      if (D.30264 == 0) goto <D.30265>; else goto <D.30266>;
      <D.30265>:
      mono_error_cleanup (&error);
      D.30231 = 0;
      return D.30231;
      <D.30266>:
      i = 0;
      goto <D.21070>;
      <D.21069>:
      D.30267 = candidate->interfaces;
      i.415 = (unsigned int) i;
      D.30269 = i.415 * 4;
      D.30270 = D.30267 + D.30269;
      D.30271 = *D.30270;
      if (D.30271 == target) goto <D.30272>; else goto <D.30273>;
      <D.30272>:
      D.30231 = 1;
      return D.30231;
      <D.30273>:
      if (is_variant != 0) goto <D.30274>; else goto <D.30275>;
      <D.30274>:
      D.30267 = candidate->interfaces;
      i.415 = (unsigned int) i;
      D.30269 = i.415 * 4;
      D.30270 = D.30267 + D.30269;
      D.30271 = *D.30270;
      D.30276 = mono_class_is_variant_compatible_slow (target, D.30271);
      if (D.30276 != 0) goto <D.30277>; else goto <D.30278>;
      <D.30277>:
      D.30231 = 1;
      return D.30231;
      <D.30278>:
      <D.30275>:
      D.30267 = candidate->interfaces;
      i.415 = (unsigned int) i;
      D.30269 = i.415 * 4;
      D.30270 = D.30267 + D.30269;
      D.30271 = *D.30270;
      D.30279 = mono_class_implement_interface_slow (target, D.30271);
      if (D.30279 != 0) goto <D.30280>; else goto <D.30281>;
      <D.30280>:
      D.30231 = 1;
      return D.30231;
      <D.30281>:
      i = i + 1;
      <D.21070>:
      D.30282 = candidate->interface_count;
      D.30283 = (int) D.30282;
      if (D.30283 > i) goto <D.21069>; else goto <D.21071>;
      <D.21071>:
      candidate = candidate->parent;
      if (candidate != 0B) goto <D.21072>; else goto <D.21073>;
      <D.21073>:
      D.30231 = 0;
      return D.30231;
    }
  finally
    {
      error = {CLOBBER};
    }
}


mono_class_is_variant_compatible_slow (struct MonoClass * klass, struct MonoClass * oklass)
{
  struct MonoClass * D.30288;
  gboolean D.30290;
  struct MonoGenericClass * D.30291;
  struct MonoGenericInst * D.30292;
  struct MonoGenericClass * D.30293;
  struct MonoGenericInst * D.30294;
  unsigned int j.416;
  unsigned int D.30296;
  struct MonoType * * D.30297;
  struct MonoType * D.30298;
  struct MonoType * * D.30299;
  struct MonoType * D.30300;
  unsigned char D.30301;
  unsigned char D.30302;
  unsigned char D.30303;
  unsigned char D.30304;
  struct MonoGenericParamFull * D.30309;
  unsigned int D.30310;
  struct MonoGenericParamFull * D.30311;
  short unsigned int D.30312;
  int D.30313;
  int D.30314;
  int D.30317;
  int D.30321;
  int D.30324;
  <unnamed-signed:31> D.30328;
  int D.30329;
  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.30288 = mono_class_get_generic_type_definition (oklass);
  if (D.30288 != klass_gtd) goto <D.30286>; else goto <D.30289>;
  <D.30289>:
  if (oklass == klass_gtd) goto <D.30286>; else goto <D.30287>;
  <D.30286>:
  D.30290 = 0;
  return D.30290;
  <D.30287>:
  D.30291 = klass->generic_class;
  D.30292 = D.30291->context.class_inst;
  klass_argv = &D.30292->type_argv[0];
  D.30293 = oklass->generic_class;
  D.30294 = D.30293->context.class_inst;
  oklass_argv = &D.30294->type_argv[0];
  j = 0;
  goto <D.21052>;
  <D.21051>:
  {
    struct MonoClass * param1_class;
    struct MonoClass * param2_class;

    j.416 = (unsigned int) j;
    D.30296 = j.416 * 4;
    D.30297 = klass_argv + D.30296;
    D.30298 = *D.30297;
    param1_class = mono_class_from_mono_type (D.30298);
    j.416 = (unsigned int) j;
    D.30296 = j.416 * 4;
    D.30299 = oklass_argv + D.30296;
    D.30300 = *D.30299;
    param2_class = mono_class_from_mono_type (D.30300);
    D.30301 = BIT_FIELD_REF <*param1_class, 8, 160>;
    D.30302 = BIT_FIELD_REF <*param2_class, 8, 160>;
    D.30303 = D.30301 ^ D.30302;
    D.30304 = D.30303 & 8;
    if (D.30304 != 0) goto <D.30305>; else goto <D.30306>;
    <D.30305>:
    D.30290 = 0;
    return D.30290;
    <D.30306>:
    if (param1_class != param2_class) goto <D.30307>; else goto <D.30308>;
    <D.30307>:
    D.30309 = container->type_params;
    j.416 = (unsigned int) j;
    D.30310 = j.416 * 32;
    D.30311 = D.30309 + D.30310;
    D.30312 = D.30311->info.flags;
    D.30313 = (int) D.30312;
    D.30314 = D.30313 & 1;
    if (D.30314 != 0) goto <D.30315>; else goto <D.30316>;
    <D.30315>:
    D.30317 = mono_class_is_assignable_from_slow (param1_class, param2_class);
    if (D.30317 == 0) goto <D.30318>; else goto <D.30319>;
    <D.30318>:
    D.30290 = 0;
    return D.30290;
    <D.30319>:
    goto <D.30320>;
    <D.30316>:
    D.30309 = container->type_params;
    j.416 = (unsigned int) j;
    D.30310 = j.416 * 32;
    D.30311 = D.30309 + D.30310;
    D.30312 = D.30311->info.flags;
    D.30313 = (int) D.30312;
    D.30321 = D.30313 & 2;
    if (D.30321 != 0) goto <D.30322>; else goto <D.30323>;
    <D.30322>:
    D.30324 = mono_class_is_assignable_from_slow (param2_class, param1_class);
    if (D.30324 == 0) goto <D.30325>; else goto <D.30326>;
    <D.30325>:
    D.30290 = 0;
    return D.30290;
    <D.30326>:
    goto <D.30327>;
    <D.30323>:
    D.30290 = 0;
    return D.30290;
    <D.30327>:
    <D.30320>:
    <D.30308>:
  }
  j = j + 1;
  <D.21052>:
  D.30328 = container->type_argc;
  D.30329 = (int) D.30328;
  if (D.30329 > j) goto <D.21051>; else goto <D.21053>;
  <D.21053>:
  D.30290 = 1;
  return D.30290;
}


mono_class_get_cctor (struct MonoClass * klass)
{
  struct MonoImage * D.30331;
  unsigned char D.30332;
  unsigned char D.30333;
  struct MonoMethod * D.30336;
  unsigned char D.30337;
  unsigned char D.30338;
  int D.30341;
  unsigned int D.30344;
  struct MonoGenericClass * D.30345;
  struct MonoMethod * * D.30348;
  struct MonoClass * D.30351;
  struct MonoMethod * D.30352;
  struct MonoCachedClassInfo cached_info;

  try
    {
      D.30331 = klass->image;
      D.30332 = BIT_FIELD_REF <*D.30331, 8, 128>;
      D.30333 = D.30332 & 8;
      if (D.30333 != 0) goto <D.30334>; else goto <D.30335>;
      <D.30334>:
      D.30336 = mono_class_get_method_from_name_flags (klass, ".cctor", -1, 2048);
      return D.30336;
      <D.30335>:
      D.30337 = BIT_FIELD_REF <*klass, 8, 184>;
      D.30338 = D.30337 & 4;
      if (D.30338 == 0) goto <D.30339>; else goto <D.30340>;
      <D.30339>:
      D.30336 = 0B;
      return D.30336;
      <D.30340>:
      D.30341 = mono_class_get_cached_class_info (klass, &cached_info);
      if (D.30341 != 0) goto <D.30342>; else goto <D.30343>;
      <D.30342>:
      D.30344 = cached_info.cctor_token;
      D.30331 = klass->image;
      D.30336 = mono_get_method (D.30331, D.30344, klass);
      return D.30336;
      <D.30343>:
      D.30345 = klass->generic_class;
      if (D.30345 != 0B) goto <D.30346>; else goto <D.30347>;
      <D.30346>:
      D.30348 = klass->methods;
      if (D.30348 == 0B) goto <D.30349>; else goto <D.30350>;
      <D.30349>:
      D.30345 = klass->generic_class;
      D.30351 = D.30345->container_class;
      D.30352 = mono_class_get_cctor (D.30351);
      D.30336 = mono_class_get_inflated_method (klass, D.30352);
      return D.30336;
      <D.30350>:
      <D.30347>:
      D.30336 = mono_class_get_method_from_name_flags (klass, ".cctor", -1, 2048);
      return D.30336;
    }
  finally
    {
      cached_info = {CLOBBER};
    }
}


mono_class_get_finalizer (struct MonoClass * klass)
{
  unsigned char D.30355;
  unsigned char D.30356;
  int D.30359;
  struct MonoMethod * D.30362;
  int D.30363;
  unsigned int D.30366;
  struct MonoImage * D.30367;
  struct MonoMethod * * D.30368;
  int finalize_slot.417;
  unsigned int finalize_slot.418;
  unsigned int D.30371;
  struct MonoMethod * * D.30372;
  struct MonoCachedClassInfo cached_info;

  try
    {
      D.30355 = BIT_FIELD_REF <*klass, 8, 160>;
      D.30356 = D.30355 & 1;
      if (D.30356 == 0) goto <D.30357>; else goto <D.30358>;
      <D.30357>:
      mono_class_init (klass);
      <D.30358>:
      D.30359 = mono_class_has_finalizer (klass);
      if (D.30359 == 0) goto <D.30360>; else goto <D.30361>;
      <D.30360>:
      D.30362 = 0B;
      return D.30362;
      <D.30361>:
      D.30363 = mono_class_get_cached_class_info (klass, &cached_info);
      if (D.30363 != 0) goto <D.30364>; else goto <D.30365>;
      <D.30364>:
      D.30366 = cached_info.finalize_token;
      D.30367 = cached_info.finalize_image;
      D.30362 = mono_get_method (D.30367, D.30366, 0B);
      return D.30362;
      <D.30365>:
      mono_class_setup_vtable (klass);
      D.30368 = klass->vtable;
      finalize_slot.417 = finalize_slot;
      finalize_slot.418 = (unsigned int) finalize_slot.417;
      D.30371 = finalize_slot.418 * 4;
      D.30372 = D.30368 + D.30371;
      D.30362 = *D.30372;
      return D.30362;
    }
  finally
    {
      cached_info = {CLOBBER};
    }
}


mono_class_needs_cctor_run (struct MonoClass * klass, struct MonoMethod * caller)
{
  gboolean D.30377;
  _Bool D.30378;
  struct MonoMethod * method;

  method = mono_class_get_cctor (klass);
  if (method != 0B) goto <D.30375>; else goto <D.30376>;
  <D.30375>:
  D.30378 = method != caller;
  D.30377 = (gboolean) D.30378;
  return D.30377;
  <D.30376>:
  D.30377 = 0;
  return D.30377;
}


mono_class_array_element_size (struct MonoClass * klass)
{
  unsigned char D.30380;
  int D.30381;
  int32_t D.30382;
  struct MonoClass * D.30383;
  unsigned char D.30384;
  unsigned char D.30385;
  int D.30388;
  unsigned int D.30389;
  unsigned int D.30390;
  struct MonoGenericClass * D.30391;
  struct MonoClass * D.30392;
  struct MonoType * type;
  void handle_enum = <<< error >>>;

  type = &klass->byval_arg;
  handle_enum:
  D.30380 = type->type;
  D.30381 = (int) D.30380;
  switch (D.30381) <default: <D.21123>, case 1: <D.21122>, case 2: <D.21100>, case 3: <D.21103>, case 4: <D.21098>, case 5: <D.21099>, case 6: <D.21101>, case 7: <D.21102>, case 8: <D.21104>, case 9: <D.21105>, case 10: <D.21117>, case 11: <D.21118>, case 12: <D.21106>, case 13: <D.21119>, case 14: <D.21111>, case 15: <D.21109>, case 17: <D.21120>, case 18: <D.21110>, case 19: <D.21115>, case 20: <D.21114>, case 21: <D.21121>, case 24: <D.21107>, case 25: <D.21108>, case 28: <D.21112>, case 29: <D.21113>, case 30: <D.21116>>
  <D.21098>:
  <D.21099>:
  <D.21100>:
  D.30382 = 1;
  return D.30382;
  <D.21101>:
  <D.21102>:
  <D.21103>:
  D.30382 = 2;
  return D.30382;
  <D.21104>:
  <D.21105>:
  <D.21106>:
  D.30382 = 4;
  return D.30382;
  <D.21107>:
  <D.21108>:
  <D.21109>:
  <D.21110>:
  <D.21111>:
  <D.21112>:
  <D.21113>:
  <D.21114>:
  <D.21115>:
  <D.21116>:
  D.30382 = 4;
  return D.30382;
  <D.21117>:
  <D.21118>:
  <D.21119>:
  D.30382 = 8;
  return D.30382;
  <D.21120>:
  D.30383 = type->data.klass;
  D.30384 = BIT_FIELD_REF <*D.30383, 8, 160>;
  D.30385 = D.30384 & 16;
  if (D.30385 != 0) goto <D.30386>; else goto <D.30387>;
  <D.30386>:
  D.30383 = type->data.klass;
  type = mono_class_enum_basetype (D.30383);
  klass = klass->element_class;
  goto handle_enum;
  <D.30387>:
  D.30388 = mono_class_instance_size (klass);
  D.30389 = (unsigned int) D.30388;
  D.30390 = D.30389 + 4294967288;
  D.30382 = (int32_t) D.30390;
  return D.30382;
  <D.21121>:
  D.30391 = type->data.generic_class;
  D.30392 = D.30391->container_class;
  type = &D.30392->byval_arg;
  goto handle_enum;
  <D.21122>:
  D.30382 = 0;
  return D.30382;
  <D.21123>:
  D.30380 = type->type;
  D.30381 = (int) D.30380;
  monoeg_g_log (0B, 4, "unknown type 0x%02x in mono_class_array_element_size", D.30381);
  <D.21124>:
  goto <D.21124>;
  D.30382 = -1;
  return D.30382;
}


mono_array_element_size (struct MonoClass * ac)
{
  unsigned char D.30394;
  _Bool D.30395;
  long int D.30396;
  long int D.30397;
  int32_t D.30400;

  D.30394 = ac->rank;
  D.30395 = D.30394 == 0;
  D.30396 = (long int) D.30395;
  D.30397 = __builtin_expect (D.30396, 0);
  if (D.30397 != 0) goto <D.30398>; else goto <D.30399>;
  <D.30398>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "class.c", 8238, "ac->rank");
  <D.30399>:
  D.30400 = ac->sizes.element_size;
  return D.30400;
}


mono_ldtoken (struct MonoImage * image, guint32 token, struct MonoClass * * handle_class, struct MonoGenericContext * context)
{
  unsigned char D.30402;
  unsigned char D.30403;
  struct MonoClass * tmp_handle_class.419;
  _Bool D.30407;
  long int D.30408;
  long int D.30409;
  struct MonoClass * D.30414;
  void * D.30417;
  unsigned int D.30418;
  struct MonoClass * D.30423;
  unsigned int D.30424;
  struct MonoClass * D.30429;
  unsigned int D.30430;
  struct MonoClass * D.30435;
  unsigned int D.30436;
  int D.30437;
  struct MonoTableInfo * D.30438;
  unsigned int D.30439;
  const char * sig.420;
  const char * sig.421;
  char D.30442;

  D.30402 = BIT_FIELD_REF <*image, 8, 128>;
  D.30403 = D.30402 & 8;
  if (D.30403 != 0) goto <D.30404>; else goto <D.30405>;
  <D.30404>:
  {
    struct MonoClass * tmp_handle_class;
    void * obj;

    try
      {
        obj = mono_lookup_dynamic_token_class (image, token, 1, &tmp_handle_class, context);
        tmp_handle_class.419 = tmp_handle_class;
        D.30407 = tmp_handle_class.419 == 0B;
        D.30408 = (long int) D.30407;
        D.30409 = __builtin_expect (D.30408, 0);
        if (D.30409 != 0) goto <D.30410>; else goto <D.30411>;
        <D.30410>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "class.c", 8250, "tmp_handle_class");
        <D.30411>:
        if (handle_class != 0B) goto <D.30412>; else goto <D.30413>;
        <D.30412>:
        tmp_handle_class.419 = tmp_handle_class;
        *handle_class = tmp_handle_class.419;
        <D.30413>:
        D.30414 = mono_defaults.typehandle_class;
        tmp_handle_class.419 = tmp_handle_class;
        if (D.30414 == tmp_handle_class.419) goto <D.30415>; else goto <D.30416>;
        <D.30415>:
        D.30417 = &MEM[(struct MonoClass *)obj].byval_arg;
        return D.30417;
        <D.30416>:
        D.30417 = obj;
        return D.30417;
      }
    finally
      {
        tmp_handle_class = {CLOBBER};
      }
  }
  <D.30405>:
  D.30418 = token & 4278190080;
  switch (D.30418) <default: <D.21152>, case 16777216: <D.21137>, case 33554432: <D.21136>, case 67108864: <D.21140>, case 100663296: <D.21143>, case 167772160: <D.21146>, case 452984832: <D.21138>, case 721420288: <D.21144>>
  <D.21136>:
  <D.21137>:
  <D.21138>:
  {
    struct MonoType * type;

    if (handle_class != 0B) goto <D.30419>; else goto <D.30420>;
    <D.30419>:
    D.30414 = mono_defaults.typehandle_class;
    *handle_class = D.30414;
    <D.30420>:
    type = mono_type_get_full (image, token, context);
    if (type == 0B) goto <D.30421>; else goto <D.30422>;
    <D.30421>:
    D.30417 = 0B;
    return D.30417;
    <D.30422>:
    D.30423 = mono_class_from_mono_type (type);
    mono_class_init (D.30423);
    D.30417 = type;
    return D.30417;
  }
  <D.21140>:
  {
    struct MonoClass * class;
    guint32 type;

    D.30424 = token & 16777215;
    type = mono_metadata_typedef_from_field (image, D.30424);
    if (type == 0) goto <D.30425>; else goto <D.30426>;
    <D.30425>:
    D.30417 = 0B;
    return D.30417;
    <D.30426>:
    if (handle_class != 0B) goto <D.30427>; else goto <D.30428>;
    <D.30427>:
    D.30429 = mono_defaults.fieldhandle_class;
    *handle_class = D.30429;
    <D.30428>:
    D.30430 = type | 33554432;
    class = mono_class_get_full (image, D.30430, context);
    if (class == 0B) goto <D.30431>; else goto <D.30432>;
    <D.30431>:
    D.30417 = 0B;
    return D.30417;
    <D.30432>:
    mono_class_init (class);
    D.30417 = mono_class_get_field (class, token);
    return D.30417;
  }
  <D.21143>:
  <D.21144>:
  {
    struct MonoMethod * meth;

    meth = mono_get_method_full (image, token, 0B, context);
    if (handle_class != 0B) goto <D.30433>; else goto <D.30434>;
    <D.30433>:
    D.30435 = mono_defaults.methodhandle_class;
    *handle_class = D.30435;
    <D.30434>:
    D.30417 = meth;
    return D.30417;
  }
  <D.21146>:
  {
    guint32 cols[3];
    const char * sig;

    try
      {
        D.30424 = token & 16777215;
        D.30436 = D.30424 + 4294967295;
        D.30437 = (int) D.30436;
        D.30438 = &image->tables[10];
        mono_metadata_decode_row (D.30438, D.30437, &cols, 3);
        D.30439 = cols[2];
        sig.420 = mono_metadata_blob_heap (image, D.30439);
        sig = sig.420;
        sig.421 = sig;
        mono_metadata_decode_blob_size (sig.421, &sig);
        sig.421 = sig;
        D.30442 = *sig.421;
        if (D.30442 == 6) goto <D.30443>; else goto <D.30444>;
        <D.30443>:
        {
          struct MonoClass * klass;
          struct MonoClassField * field;

          try
            {
              field = mono_field_from_token (image, token, &klass, context);
              if (handle_class != 0B) goto <D.30445>; else goto <D.30446>;
              <D.30445>:
              D.30429 = mono_defaults.fieldhandle_class;
              *handle_class = D.30429;
              <D.30446>:
              D.30417 = field;
              return D.30417;
            }
          finally
            {
              klass = {CLOBBER};
            }
        }
        <D.30444>:
        {
          struct MonoMethod * meth;

          meth = mono_get_method_full (image, token, 0B, context);
          if (handle_class != 0B) goto <D.30447>; else goto <D.30448>;
          <D.30447>:
          D.30435 = mono_defaults.methodhandle_class;
          *handle_class = D.30435;
          <D.30448>:
          D.30417 = meth;
          return D.30417;
        }
      }
    finally
      {
        cols = {CLOBBER};
        sig = {CLOBBER};
      }
  }
  <D.21152>:
  monoeg_g_log (0B, 16, "Unknown token 0x%08x in ldtoken", token);
  goto <D.21153>;
  <D.21153>:
  D.30417 = 0B;
  return D.30417;
}


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


mono_lookup_dynamic_token (struct MonoImage * image, guint32 token, struct MonoGenericContext * context)
{
  void * D.30453;
  void * (*<T1e1f>) (struct MonoImage *, guint32, gboolean, struct MonoClass * *, struct MonoGenericContext *) lookup_dynamic.422;
  struct MonoClass * handle_class;

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


mono_lookup_dynamic_token_class (struct MonoImage * image, guint32 token, gboolean valid_token, struct MonoClass * * handle_class, struct MonoGenericContext * context)
{
  void * D.30457;
  void * (*<T1e1f>) (struct MonoImage *, guint32, gboolean, struct MonoClass * *, struct MonoGenericContext *) lookup_dynamic.423;

  lookup_dynamic.423 = lookup_dynamic;
  D.30457 = lookup_dynamic.423 (image, token, valid_token, handle_class, context);
  return D.30457;
}


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


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

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


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

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


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

  D.30465 = klass->valuetype;
  D.30464 = (mono_bool) D.30465;
  return D.30464;
}


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

  D.30468 = klass->enumtype;
  D.30467 = (mono_bool) D.30468;
  return D.30467;
}


mono_class_enum_basetype (struct MonoClass * klass)
{
  struct MonoClass * D.30470;
  struct MonoType * D.30473;

  D.30470 = klass->element_class;
  if (D.30470 == klass) goto <D.30471>; else goto <D.30472>;
  <D.30471>:
  D.30473 = 0B;
  return D.30473;
  <D.30472>:
  D.30470 = klass->element_class;
  D.30473 = &D.30470->byval_arg;
  return D.30473;
}


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

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


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

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


mono_class_get_rank (struct MonoClass * klass)
{
  int D.30479;
  unsigned char D.30480;

  D.30480 = klass->rank;
  D.30479 = (int) D.30480;
  return D.30479;
}


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

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


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

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


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

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


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

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


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

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


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

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


mono_class_num_fields (struct MonoClass * klass)
{
  int D.30494;
  unsigned int D.30495;

  D.30495 = klass->field.count;
  D.30494 = (int) D.30495;
  return D.30494;
}


mono_class_num_methods (struct MonoClass * klass)
{
  int D.30497;
  unsigned int D.30498;

  D.30498 = klass->method.count;
  D.30497 = (int) D.30498;
  return D.30497;
}


mono_class_num_properties (struct MonoClass * klass)
{
  int D.30500;
  struct MonoClassExt * D.30501;
  unsigned int D.30502;

  mono_class_setup_properties (klass);
  D.30501 = klass->ext;
  D.30502 = D.30501->property.count;
  D.30500 = (int) D.30502;
  return D.30500;
}


mono_class_setup_properties (struct MonoClass * class)
{
  struct MonoImage * D.30504;
  struct MonoClassExt * D.30505;
  struct MonoProperty * D.30508;
  struct MonoGenericClass * D.30515;
  unsigned char D.30518;
  gchar * D.30521;
  struct MonoClassExt * D.30522;
  unsigned int D.30523;
  unsigned int D.30524;
  unsigned int D.30525;
  int D.30526;
  unsigned int D.30527;
  struct MonoProperty * D.30528;
  struct MonoProperty * D.30529;
  struct MonoMethod * D.30530;
  struct MonoGenericContext * D.30533;
  struct MonoMethod * D.30534;
  struct MonoMethod * D.30535;
  struct MonoGenericContext * D.30538;
  struct MonoMethod * D.30539;
  unsigned int D.30541;
  unsigned int D.30542;
  unsigned int D.30543;
  unsigned int D.30544;
  unsigned int last.424;
  unsigned int first.425;
  unsigned int D.30547;
  unsigned char D.30550;
  unsigned int count.426;
  unsigned int count.427;
  unsigned int D.30555;
  int D.30556;
  int i.428;
  unsigned int first.429;
  unsigned int D.30559;
  unsigned int D.30560;
  struct MonoProperty * D.30561;
  unsigned int D.30562;
  unsigned int D.30563;
  const char * D.30564;
  int j.430;
  unsigned char D.30566;
  unsigned char D.30567;
  unsigned int D.30570;
  struct MonoMethod * * D.30572;
  unsigned int D.30573;
  unsigned int D.30574;
  unsigned int D.30575;
  unsigned int D.30576;
  struct MonoMethod * * D.30577;
  unsigned int endm.431;
  guint startm;
  guint endm;
  guint i;
  guint j;
  guint32 cols[3];
  struct MonoTableInfo * msemt;
  struct MonoProperty * properties;
  guint32 last;

  try
    {
      D.30504 = class->image;
      msemt = &D.30504->tables[24];
      D.30505 = class->ext;
      if (D.30505 != 0B) goto <D.30506>; else goto <D.30507>;
      <D.30506>:
      D.30505 = class->ext;
      D.30508 = D.30505->properties;
      if (D.30508 != 0B) goto <D.30509>; else goto <D.30510>;
      <D.30509>:
      return;
      <D.30510>:
      <D.30507>:
      mono_loader_lock ();
      D.30505 = class->ext;
      if (D.30505 != 0B) goto <D.30511>; else goto <D.30512>;
      <D.30511>:
      D.30505 = class->ext;
      D.30508 = D.30505->properties;
      if (D.30508 != 0B) goto <D.30513>; else goto <D.30514>;
      <D.30513>:
      mono_loader_unlock ();
      return;
      <D.30514>:
      <D.30512>:
      mono_class_alloc_ext (class);
      D.30515 = class->generic_class;
      if (D.30515 != 0B) goto <D.30516>; else goto <D.30517>;
      <D.30516>:
      {
        struct MonoClass * gklass;

        D.30515 = class->generic_class;
        gklass = D.30515->container_class;
        mono_class_init (gklass);
        mono_class_setup_properties (gklass);
        D.30518 = gklass->exception_type;
        if (D.30518 != 0) goto <D.30519>; else goto <D.30520>;
        <D.30519>:
        D.30521 = monoeg_strdup ("Generic type definition failed to load");
        mono_class_set_failure (class, 7, D.30521);
        mono_loader_unlock ();
        return;
        <D.30520>:
        D.30505 = class->ext;
        D.30522 = gklass->ext;
        D.30505->property = D.30522->property;
        D.30505 = class->ext;
        D.30523 = D.30505->property.count;
        D.30524 = D.30523 + 1;
        D.30525 = D.30524 * 20;
        D.30526 = (int) D.30525;
        properties = mono_class_alloc0 (class, D.30526);
        i = 0;
        goto <D.19013>;
        <D.19012>:
        {
          struct MonoProperty * prop;

          D.30527 = i * 20;
          prop = properties + D.30527;
          D.30522 = gklass->ext;
          D.30528 = D.30522->properties;
          D.30527 = i * 20;
          D.30529 = D.30528 + D.30527;
          *prop = *D.30529;
          D.30530 = prop->get;
          if (D.30530 != 0B) goto <D.30531>; else goto <D.30532>;
          <D.30531>:
          D.30533 = mono_class_get_context (class);
          D.30530 = prop->get;
          D.30534 = mono_class_inflate_generic_method_full (D.30530, class, D.30533);
          prop->get = D.30534;
          <D.30532>:
          D.30535 = prop->set;
          if (D.30535 != 0B) goto <D.30536>; else goto <D.30537>;
          <D.30536>:
          D.30538 = mono_class_get_context (class);
          D.30535 = prop->set;
          D.30539 = mono_class_inflate_generic_method_full (D.30535, class, D.30538);
          prop->set = D.30539;
          <D.30537>:
          prop->parent = class;
        }
        i = i + 1;
        <D.19013>:
        D.30505 = class->ext;
        D.30523 = D.30505->property.count;
        if (D.30523 > i) goto <D.19012>; else goto <D.19014>;
        <D.19014>:
      }
      goto <D.30540>;
      <D.30517>:
      {
        int first;
        int count;

        D.30541 = class->type_token;
        D.30542 = D.30541 & 16777215;
        D.30543 = D.30542 + 4294967295;
        D.30504 = class->image;
        D.30544 = mono_metadata_properties_from_typedef (D.30504, D.30543, &last);
        first = (int) D.30544;
        last.424 = last;
        first.425 = (unsigned int) first;
        D.30547 = last.424 - first.425;
        count = (int) D.30547;
        if (count != 0) goto <D.30548>; else goto <D.30549>;
        <D.30548>:
        mono_class_setup_methods (class);
        D.30550 = class->exception_type;
        if (D.30550 != 0) goto <D.30551>; else goto <D.30552>;
        <D.30551>:
        mono_loader_unlock ();
        return;
        <D.30552>:
        <D.30549>:
        D.30505 = class->ext;
        first.425 = (unsigned int) first;
        D.30505->property.first = first.425;
        D.30505 = class->ext;
        count.426 = (unsigned int) count;
        D.30505->property.count = count.426;
        count.427 = (unsigned int) count;
        D.30555 = count.427 * 20;
        D.30556 = (int) D.30555;
        properties = mono_class_alloc0 (class, D.30556);
        i = (guint) first;
        goto <D.19026>;
        <D.19025>:
        i.428 = (int) i;
        D.30504 = class->image;
        mono_metadata_decode_table_row (D.30504, 23, i.428, &cols, 3);
        first.429 = (unsigned int) first;
        D.30559 = i - first.429;
        D.30560 = D.30559 * 20;
        D.30561 = properties + D.30560;
        D.30561->parent = class;
        first.429 = (unsigned int) first;
        D.30559 = i - first.429;
        D.30560 = D.30559 * 20;
        D.30561 = properties + D.30560;
        D.30562 = cols[0];
        D.30561->attrs = D.30562;
        first.429 = (unsigned int) first;
        D.30559 = i - first.429;
        D.30560 = D.30559 * 20;
        D.30561 = properties + D.30560;
        D.30563 = cols[1];
        D.30504 = class->image;
        D.30564 = mono_metadata_string_heap (D.30504, D.30563);
        D.30561->name = D.30564;
        D.30504 = class->image;
        startm = mono_metadata_methods_from_property (D.30504, i, &endm);
        j = startm;
        goto <D.19023>;
        <D.19022>:
        {
          struct MonoMethod * method;

          j.430 = (int) j;
          mono_metadata_decode_row (msemt, j.430, &cols, 3);
          D.30504 = class->image;
          D.30566 = BIT_FIELD_REF <*D.30504, 8, 128>;
          D.30567 = D.30566 & 32;
          if (D.30567 != 0) goto <D.30568>; else goto <D.30569>;
          <D.30568>:
          D.30563 = cols[1];
          D.30570 = D.30563 | 100663296;
          D.30504 = class->image;
          method = mono_get_method (D.30504, D.30570, class);
          goto <D.30571>;
          <D.30569>:
          D.30572 = class->methods;
          D.30563 = cols[1];
          D.30573 = class->method.first;
          D.30574 = D.30563 - D.30573;
          D.30575 = D.30574 + 1073741823;
          D.30576 = D.30575 * 4;
          D.30577 = D.30572 + D.30576;
          method = *D.30577;
          <D.30571>:
          D.30562 = cols[0];
          switch (D.30562) <default: <D.19021>, case 1: <D.19018>, case 2: <D.19020>>
          <D.19018>:
          first.429 = (unsigned int) first;
          D.30559 = i - first.429;
          D.30560 = D.30559 * 20;
          D.30561 = properties + D.30560;
          D.30561->set = method;
          goto <D.19019>;
          <D.19020>:
          first.429 = (unsigned int) first;
          D.30559 = i - first.429;
          D.30560 = D.30559 * 20;
          D.30561 = properties + D.30560;
          D.30561->get = method;
          goto <D.19019>;
          <D.19021>:
          goto <D.19019>;
          <D.19019>:
        }
        j = j + 1;
        <D.19023>:
        endm.431 = endm;
        if (j < endm.431) goto <D.19022>; else goto <D.19024>;
        <D.19024>:
        i = i + 1;
        <D.19026>:
        last.424 = last;
        if (i < last.424) goto <D.19025>; else goto <D.19027>;
        <D.19027>:
      }
      <D.30540>:
      mono_memory_barrier ();
      D.30505 = class->ext;
      D.30505->properties = properties;
      mono_loader_unlock ();
    }
  finally
    {
      endm = {CLOBBER};
      cols = {CLOBBER};
      last = {CLOBBER};
    }
}


mono_class_num_events (struct MonoClass * klass)
{
  int D.30583;
  struct MonoClassExt * D.30584;
  unsigned int D.30585;

  mono_class_setup_events (klass);
  D.30584 = klass->ext;
  D.30585 = D.30584->event.count;
  D.30583 = (int) D.30585;
  return D.30583;
}


mono_class_setup_events (struct MonoClass * class)
{
  struct MonoImage * D.30587;
  struct MonoClassExt * D.30588;
  struct MonoEvent * D.30591;
  struct MonoGenericClass * D.30598;
  unsigned char D.30601;
  gchar * D.30604;
  struct MonoClassExt * D.30605;
  unsigned int D.30606;
  unsigned int D.30607;
  int D.30608;
  void * D.30609;
  unsigned int D.30612;
  struct MonoEvent * D.30613;
  const char * D.30614;
  struct MonoMethod * iftmp.432;
  struct MonoMethod * D.30616;
  struct MonoMethod * iftmp.433;
  struct MonoMethod * D.30621;
  struct MonoMethod * iftmp.434;
  struct MonoMethod * D.30626;
  struct MonoMethod * * iftmp.435;
  struct MonoMethod * * D.30631;
  unsigned int D.30635;
  unsigned int D.30636;
  unsigned int D.30637;
  unsigned int D.30638;
  unsigned int D.30639;
  unsigned int last.436;
  unsigned int first.437;
  unsigned int D.30642;
  unsigned char D.30645;
  gchar * D.30648;
  unsigned int count.438;
  unsigned int first.439;
  unsigned int D.30651;
  unsigned int D.30652;
  int i.440;
  unsigned int D.30654;
  unsigned int D.30655;
  const char * D.30656;
  int j.441;
  unsigned char D.30658;
  unsigned char D.30659;
  unsigned int D.30662;
  struct MonoMethod * * D.30664;
  unsigned int D.30665;
  unsigned int D.30666;
  unsigned int D.30667;
  unsigned int D.30668;
  struct MonoMethod * * D.30669;
  struct MonoMethod * * D.30670;
  void * D.30673;
  unsigned int n.442;
  unsigned int D.30676;
  struct MonoMethod * * D.30677;
  struct MonoMethod * D.30678;
  int D.30679;
  unsigned int D.30680;
  unsigned int D.30681;
  void * D.30682;
  sizetype n.443;
  sizetype D.30684;
  sizetype D.30685;
  struct MonoMethod * * D.30686;
  unsigned int endm.444;
  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.30587 = class->image;
      msemt = &D.30587->tables[24];
      D.30588 = class->ext;
      if (D.30588 != 0B) goto <D.30589>; else goto <D.30590>;
      <D.30589>:
      D.30588 = class->ext;
      D.30591 = D.30588->events;
      if (D.30591 != 0B) goto <D.30592>; else goto <D.30593>;
      <D.30592>:
      return;
      <D.30593>:
      <D.30590>:
      mono_loader_lock ();
      D.30588 = class->ext;
      if (D.30588 != 0B) goto <D.30594>; else goto <D.30595>;
      <D.30594>:
      D.30588 = class->ext;
      D.30591 = D.30588->events;
      if (D.30591 != 0B) goto <D.30596>; else goto <D.30597>;
      <D.30596>:
      mono_loader_unlock ();
      return;
      <D.30597>:
      <D.30595>:
      mono_class_alloc_ext (class);
      D.30598 = class->generic_class;
      if (D.30598 != 0B) goto <D.30599>; else goto <D.30600>;
      <D.30599>:
      {
        struct MonoClass * gklass;
        struct MonoGenericContext * context;

        D.30598 = class->generic_class;
        gklass = D.30598->container_class;
        mono_class_setup_events (gklass);
        D.30601 = gklass->exception_type;
        if (D.30601 != 0) goto <D.30602>; else goto <D.30603>;
        <D.30602>:
        D.30604 = monoeg_strdup ("Generic type definition failed to load");
        mono_class_set_failure (class, 7, D.30604);
        mono_loader_unlock ();
        return;
        <D.30603>:
        D.30588 = class->ext;
        D.30605 = gklass->ext;
        D.30588->event = D.30605->event;
        D.30588 = class->ext;
        D.30588 = class->ext;
        D.30606 = D.30588->event.count;
        D.30607 = D.30606 * 28;
        D.30608 = (int) D.30607;
        D.30609 = mono_class_alloc0 (class, D.30608);
        D.30588->events = D.30609;
        D.30588 = class->ext;
        D.30606 = D.30588->event.count;
        if (D.30606 != 0) goto <D.30610>; else goto <D.30611>;
        <D.30610>:
        context = mono_class_get_context (class);
        <D.30611>:
        i = 0;
        goto <D.19060>;
        <D.19059>:
        {
          struct MonoEvent * event;
          struct MonoEvent * gevent;

          D.30588 = class->ext;
          D.30591 = D.30588->events;
          D.30612 = i * 28;
          event = D.30591 + D.30612;
          D.30605 = gklass->ext;
          D.30613 = D.30605->events;
          D.30612 = i * 28;
          gevent = D.30613 + D.30612;
          event->parent = class;
          D.30614 = gevent->name;
          event->name = D.30614;
          D.30616 = gevent->add;
          if (D.30616 != 0B) goto <D.30617>; else goto <D.30618>;
          <D.30617>:
          D.30616 = gevent->add;
          iftmp.432 = mono_class_inflate_generic_method_full (D.30616, class, context);
          goto <D.30619>;
          <D.30618>:
          iftmp.432 = 0B;
          <D.30619>:
          event->add = iftmp.432;
          D.30621 = gevent->remove;
          if (D.30621 != 0B) goto <D.30622>; else goto <D.30623>;
          <D.30622>:
          D.30621 = gevent->remove;
          iftmp.433 = mono_class_inflate_generic_method_full (D.30621, class, context);
          goto <D.30624>;
          <D.30623>:
          iftmp.433 = 0B;
          <D.30624>:
          event->remove = iftmp.433;
          D.30626 = gevent->raise;
          if (D.30626 != 0B) goto <D.30627>; else goto <D.30628>;
          <D.30627>:
          D.30626 = gevent->raise;
          iftmp.434 = mono_class_inflate_generic_method_full (D.30626, class, context);
          goto <D.30629>;
          <D.30628>:
          iftmp.434 = 0B;
          <D.30629>:
          event->raise = iftmp.434;
          D.30631 = gevent->other;
          if (D.30631 != 0B) goto <D.30632>; else goto <D.30633>;
          <D.30632>:
          D.30631 = gevent->other;
          iftmp.435 = inflate_method_listz (D.30631, class, context);
          goto <D.30634>;
          <D.30633>:
          iftmp.435 = 0B;
          <D.30634>:
          event->other = iftmp.435;
          D.30635 = gevent->attrs;
          event->attrs = D.30635;
        }
        i = i + 1;
        <D.19060>:
        D.30588 = class->ext;
        D.30606 = D.30588->event.count;
        if (D.30606 > i) goto <D.19059>; else goto <D.19061>;
        <D.19061>:
        mono_loader_unlock ();
        return;
      }
      <D.30600>:
      D.30636 = class->type_token;
      D.30637 = D.30636 & 16777215;
      D.30638 = D.30637 + 4294967295;
      D.30587 = class->image;
      D.30639 = mono_metadata_events_from_typedef (D.30587, D.30638, &last);
      first = (int) D.30639;
      last.436 = last;
      first.437 = (unsigned int) first;
      D.30642 = last.436 - first.437;
      count = (int) D.30642;
      if (count != 0) goto <D.30643>; else goto <D.30644>;
      <D.30643>:
      mono_class_setup_methods (class);
      D.30645 = class->exception_type;
      if (D.30645 != 0) goto <D.30646>; else goto <D.30647>;
      <D.30646>:
      D.30648 = monoeg_strdup ("Generic type definition failed to load");
      mono_class_set_failure (class, 7, D.30648);
      mono_loader_unlock ();
      return;
      <D.30647>:
      <D.30644>:
      D.30588 = class->ext;
      first.437 = (unsigned int) first;
      D.30588->event.first = first.437;
      D.30588 = class->ext;
      count.438 = (unsigned int) count;
      D.30588->event.count = count.438;
      D.30588 = class->ext;
      D.30606 = D.30588->event.count;
      D.30607 = D.30606 * 28;
      D.30608 = (int) D.30607;
      events = mono_class_alloc0 (class, D.30608);
      i = (guint) first;
      goto <D.19078>;
      <D.19077>:
      {
        struct MonoEvent * event;

        first.439 = (unsigned int) first;
        D.30651 = i - first.439;
        D.30652 = D.30651 * 28;
        event = events + D.30652;
        i.440 = (int) i;
        D.30587 = class->image;
        mono_metadata_decode_table_row (D.30587, 20, i.440, &cols, 3);
        event->parent = class;
        D.30654 = cols[0];
        event->attrs = D.30654;
        D.30655 = cols[1];
        D.30587 = class->image;
        D.30656 = mono_metadata_string_heap (D.30587, D.30655);
        event->name = D.30656;
        D.30587 = class->image;
        startm = mono_metadata_methods_from_event (D.30587, i, &endm);
        j = startm;
        goto <D.19075>;
        <D.19074>:
        {
          struct MonoMethod * method;

          j.441 = (int) j;
          mono_metadata_decode_row (msemt, j.441, &cols, 3);
          D.30587 = class->image;
          D.30658 = BIT_FIELD_REF <*D.30587, 8, 128>;
          D.30659 = D.30658 & 32;
          if (D.30659 != 0) goto <D.30660>; else goto <D.30661>;
          <D.30660>:
          D.30655 = cols[1];
          D.30662 = D.30655 | 100663296;
          D.30587 = class->image;
          method = mono_get_method (D.30587, D.30662, class);
          goto <D.30663>;
          <D.30661>:
          D.30664 = class->methods;
          D.30655 = cols[1];
          D.30665 = class->method.first;
          D.30666 = D.30655 - D.30665;
          D.30667 = D.30666 + 1073741823;
          D.30668 = D.30667 * 4;
          D.30669 = D.30664 + D.30668;
          method = *D.30669;
          <D.30663>:
          D.30654 = cols[0];
          switch (D.30654) <default: <D.19073>, case 4: <D.19068>, case 8: <D.19064>, case 16: <D.19066>, case 32: <D.19067>>
          <D.19064>:
          event->add = method;
          goto <D.19065>;
          <D.19066>:
          event->remove = method;
          goto <D.19065>;
          <D.19067>:
          event->raise = method;
          goto <D.19065>;
          <D.19068>:
          {
            int n;

            n = 0;
            D.30670 = event->other;
            if (D.30670 == 0B) goto <D.30671>; else goto <D.30672>;
            <D.30671>:
            D.30673 = monoeg_malloc0 (8);
            event->other = D.30673;
            goto <D.30674>;
            <D.30672>:
            goto <D.19071>;
            <D.19070>:
            n = n + 1;
            <D.19071>:
            D.30670 = event->other;
            n.442 = (unsigned int) n;
            D.30676 = n.442 * 4;
            D.30677 = D.30670 + D.30676;
            D.30678 = *D.30677;
            if (D.30678 != 0B) goto <D.19070>; else goto <D.19072>;
            <D.19072>:
            D.30679 = n + 2;
            D.30680 = (unsigned int) D.30679;
            D.30681 = D.30680 * 4;
            D.30670 = event->other;
            D.30682 = monoeg_realloc (D.30670, D.30681);
            event->other = D.30682;
            <D.30674>:
            D.30670 = event->other;
            n.442 = (unsigned int) n;
            D.30676 = n.442 * 4;
            D.30677 = D.30670 + D.30676;
            *D.30677 = method;
            D.30670 = event->other;
            n.443 = (sizetype) n;
            D.30684 = n.443 + 1;
            D.30685 = D.30684 * 4;
            D.30686 = D.30670 + D.30685;
            *D.30686 = 0B;
            goto <D.19065>;
          }
          <D.19073>:
          goto <D.19065>;
          <D.19065>:
        }
        j = j + 1;
        <D.19075>:
        endm.444 = endm;
        if (j < endm.444) goto <D.19074>; else goto <D.19076>;
        <D.19076>:
      }
      i = i + 1;
      <D.19078>:
      last.436 = last;
      if (i < last.436) goto <D.19077>; else goto <D.19079>;
      <D.19079>:
      mono_memory_barrier ();
      D.30588 = class->ext;
      D.30588->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.30692;
  int D.30693;
  unsigned int D.30694;
  unsigned int D.30695;
  unsigned int count.445;
  unsigned int D.30697;
  struct MonoMethod * * D.30698;
  struct MonoMethod * D.30699;
  struct MonoMethod * * D.30700;
  struct MonoMethod * * om;
  struct MonoMethod * * retval;
  int count;

  om = methods;
  count = 0;
  goto <D.19037>;
  <D.19036>:
  om = om + 4;
  count = count + 1;
  <D.19037>:
  D.30692 = *om;
  if (D.30692 != 0B) goto <D.19036>; else goto <D.19038>;
  <D.19038>:
  D.30693 = count + 1;
  D.30694 = (unsigned int) D.30693;
  D.30695 = D.30694 * 4;
  retval = monoeg_malloc0 (D.30695);
  count = 0;
  om = methods;
  count = 0;
  goto <D.19040>;
  <D.19039>:
  count.445 = (unsigned int) count;
  D.30697 = count.445 * 4;
  D.30698 = retval + D.30697;
  D.30692 = *om;
  D.30699 = mono_class_inflate_generic_method_full (D.30692, class, context);
  *D.30698 = D.30699;
  om = om + 4;
  count = count + 1;
  <D.19040>:
  D.30692 = *om;
  if (D.30692 != 0B) goto <D.19039>; else goto <D.19041>;
  <D.19041>:
  D.30700 = retval;
  return D.30700;
}


mono_class_get_fields (struct MonoClass * klass, void * * iter)
{
  struct MonoClassField * D.30704;
  void * D.30705;
  unsigned char D.30708;
  unsigned int D.30711;
  struct MonoClassField * D.30714;
  unsigned int D.30715;
  struct MonoClassField * D.30716;
  struct MonoClassField * field;

  if (iter == 0B) goto <D.30702>; else goto <D.30703>;
  <D.30702>:
  D.30704 = 0B;
  return D.30704;
  <D.30703>:
  D.30705 = *iter;
  if (D.30705 == 0B) goto <D.30706>; else goto <D.30707>;
  <D.30706>:
  mono_class_setup_fields_locking (klass);
  D.30708 = klass->exception_type;
  if (D.30708 != 0) goto <D.30709>; else goto <D.30710>;
  <D.30709>:
  D.30704 = 0B;
  return D.30704;
  <D.30710>:
  D.30711 = klass->field.count;
  if (D.30711 != 0) goto <D.30712>; else goto <D.30713>;
  <D.30712>:
  D.30714 = klass->fields;
  *iter = D.30714;
  D.30704 = *iter;
  return D.30704;
  <D.30713>:
  D.30704 = 0B;
  return D.30704;
  <D.30707>:
  field = *iter;
  field = field + 16;
  D.30714 = klass->fields;
  D.30711 = klass->field.count;
  D.30715 = D.30711 * 16;
  D.30716 = D.30714 + D.30715;
  if (D.30716 > field) goto <D.30717>; else goto <D.30718>;
  <D.30717>:
  *iter = field;
  D.30704 = *iter;
  return D.30704;
  <D.30718>:
  D.30704 = 0B;
  return D.30704;
}


mono_class_get_methods (struct MonoClass * klass, void * * iter)
{
  struct MonoMethod * D.30722;
  void * D.30723;
  struct MonoMethod * * D.30726;
  unsigned int D.30729;
  unsigned int D.30732;
  struct MonoMethod * * D.30733;
  struct MonoMethod * * method;

  if (iter == 0B) goto <D.30720>; else goto <D.30721>;
  <D.30720>:
  D.30722 = 0B;
  return D.30722;
  <D.30721>:
  D.30723 = *iter;
  if (D.30723 == 0B) goto <D.30724>; else goto <D.30725>;
  <D.30724>:
  mono_class_setup_methods (klass);
  D.30726 = klass->methods;
  if (D.30726 == 0B) goto <D.30727>; else goto <D.30728>;
  <D.30727>:
  D.30722 = 0B;
  return D.30722;
  <D.30728>:
  D.30729 = klass->method.count;
  if (D.30729 != 0) goto <D.30730>; else goto <D.30731>;
  <D.30730>:
  D.30726 = klass->methods;
  *iter = D.30726;
  D.30726 = klass->methods;
  D.30722 = *D.30726;
  return D.30722;
  <D.30731>:
  D.30722 = 0B;
  return D.30722;
  <D.30725>:
  method = *iter;
  method = method + 4;
  D.30726 = klass->methods;
  D.30729 = klass->method.count;
  D.30732 = D.30729 * 4;
  D.30733 = D.30726 + D.30732;
  if (D.30733 > method) goto <D.30734>; else goto <D.30735>;
  <D.30734>:
  *iter = method;
  D.30722 = *method;
  return D.30722;
  <D.30735>:
  D.30722 = 0B;
  return D.30722;
}


mono_class_get_properties (struct MonoClass * klass, void * * iter)
{
  struct MonoProperty * D.30739;
  void * D.30740;
  struct MonoClassExt * D.30743;
  unsigned int D.30744;
  struct MonoProperty * D.30747;
  unsigned int D.30748;
  struct MonoProperty * D.30749;
  struct MonoProperty * property;

  if (iter == 0B) goto <D.30737>; else goto <D.30738>;
  <D.30737>:
  D.30739 = 0B;
  return D.30739;
  <D.30738>:
  D.30740 = *iter;
  if (D.30740 == 0B) goto <D.30741>; else goto <D.30742>;
  <D.30741>:
  mono_class_setup_properties (klass);
  D.30743 = klass->ext;
  D.30744 = D.30743->property.count;
  if (D.30744 != 0) goto <D.30745>; else goto <D.30746>;
  <D.30745>:
  D.30743 = klass->ext;
  D.30747 = D.30743->properties;
  *iter = D.30747;
  D.30739 = *iter;
  return D.30739;
  <D.30746>:
  D.30739 = 0B;
  return D.30739;
  <D.30742>:
  property = *iter;
  property = property + 20;
  D.30743 = klass->ext;
  D.30747 = D.30743->properties;
  D.30743 = klass->ext;
  D.30744 = D.30743->property.count;
  D.30748 = D.30744 * 20;
  D.30749 = D.30747 + D.30748;
  if (D.30749 > property) goto <D.30750>; else goto <D.30751>;
  <D.30750>:
  *iter = property;
  D.30739 = *iter;
  return D.30739;
  <D.30751>:
  D.30739 = 0B;
  return D.30739;
}


mono_class_get_events (struct MonoClass * klass, void * * iter)
{
  struct MonoEvent * D.30755;
  void * D.30756;
  struct MonoClassExt * D.30759;
  unsigned int D.30760;
  struct MonoEvent * D.30763;
  unsigned int D.30764;
  struct MonoEvent * D.30765;
  struct MonoEvent * event;

  if (iter == 0B) goto <D.30753>; else goto <D.30754>;
  <D.30753>:
  D.30755 = 0B;
  return D.30755;
  <D.30754>:
  D.30756 = *iter;
  if (D.30756 == 0B) goto <D.30757>; else goto <D.30758>;
  <D.30757>:
  mono_class_setup_events (klass);
  D.30759 = klass->ext;
  D.30760 = D.30759->event.count;
  if (D.30760 != 0) goto <D.30761>; else goto <D.30762>;
  <D.30761>:
  D.30759 = klass->ext;
  D.30763 = D.30759->events;
  *iter = D.30763;
  D.30755 = *iter;
  return D.30755;
  <D.30762>:
  D.30755 = 0B;
  return D.30755;
  <D.30758>:
  event = *iter;
  event = event + 28;
  D.30759 = klass->ext;
  D.30763 = D.30759->events;
  D.30759 = klass->ext;
  D.30760 = D.30759->event.count;
  D.30764 = D.30760 * 28;
  D.30765 = D.30763 + D.30764;
  if (D.30765 > event) goto <D.30766>; else goto <D.30767>;
  <D.30766>:
  *iter = event;
  D.30755 = *iter;
  return D.30755;
  <D.30767>:
  D.30755 = 0B;
  return D.30755;
}


mono_class_get_interfaces (struct MonoClass * klass, void * * iter)
{
  struct MonoClass * D.30771;
  void * D.30772;
  unsigned char D.30775;
  unsigned char D.30776;
  unsigned char D.30779;
  unsigned char D.30780;
  int D.30783;
  short unsigned int D.30786;
  struct MonoClass * * D.30789;
  unsigned int D.30790;
  unsigned int D.30791;
  struct MonoClass * * D.30792;
  struct MonoError error;
  struct MonoClass * * iface;

  try
    {
      if (iter == 0B) goto <D.30769>; else goto <D.30770>;
      <D.30769>:
      D.30771 = 0B;
      return D.30771;
      <D.30770>:
      D.30772 = *iter;
      if (D.30772 == 0B) goto <D.30773>; else goto <D.30774>;
      <D.30773>:
      D.30775 = BIT_FIELD_REF <*klass, 8, 160>;
      D.30776 = D.30775 & 1;
      if (D.30776 == 0) goto <D.30777>; else goto <D.30778>;
      <D.30777>:
      mono_class_init (klass);
      <D.30778>:
      D.30779 = BIT_FIELD_REF <*klass, 8, 192>;
      D.30780 = D.30779 & 1;
      if (D.30780 == 0) goto <D.30781>; else goto <D.30782>;
      <D.30781>:
      mono_class_setup_interfaces (klass, &error);
      D.30783 = mono_error_ok (&error);
      if (D.30783 == 0) goto <D.30784>; else goto <D.30785>;
      <D.30784>:
      mono_error_cleanup (&error);
      D.30771 = 0B;
      return D.30771;
      <D.30785>:
      <D.30782>:
      D.30786 = klass->interface_count;
      if (D.30786 != 0) goto <D.30787>; else goto <D.30788>;
      <D.30787>:
      D.30789 = klass->interfaces;
      *iter = D.30789;
      D.30789 = klass->interfaces;
      D.30771 = *D.30789;
      return D.30771;
      <D.30788>:
      D.30771 = 0B;
      return D.30771;
      <D.30774>:
      iface = *iter;
      iface = iface + 4;
      D.30789 = klass->interfaces;
      D.30786 = klass->interface_count;
      D.30790 = (unsigned int) D.30786;
      D.30791 = D.30790 * 4;
      D.30792 = D.30789 + D.30791;
      if (D.30792 > iface) goto <D.30793>; else goto <D.30794>;
      <D.30793>:
      *iter = iface;
      D.30771 = *iface;
      return D.30771;
      <D.30794>:
      D.30771 = 0B;
      return D.30771;
    }
  finally
    {
      error = {CLOBBER};
    }
}


mono_class_get_nested_types (struct MonoClass * klass, void * * iter)
{
  struct MonoClass * D.30799;
  unsigned char D.30800;
  unsigned char D.30801;
  unsigned int D.30804;
  struct MonoImage * D.30809;
  unsigned int D.30810;
  int D.30811;
  struct MonoTableInfo * D.30812;
  unsigned int D.30813;
  unsigned int D.30814;
  int D.30815;
  int D.30818;
  unsigned int D.30819;
  unsigned int D.30820;
  struct MonoClassExt * D.30821;
  struct GList * D.30822;
  struct GList * D.30823;
  unsigned int D.30824;
  void * D.30825;
  struct MonoError error;
  struct GList * item;
  int i;

  try
    {
      if (iter == 0B) goto <D.30797>; else goto <D.30798>;
      <D.30797>:
      D.30799 = 0B;
      return D.30799;
      <D.30798>:
      D.30800 = BIT_FIELD_REF <*klass, 8, 184>;
      D.30801 = D.30800 & 128;
      if (D.30801 == 0) goto <D.30802>; else goto <D.30803>;
      <D.30802>:
      D.30804 = klass->type_token;
      if (D.30804 == 0) goto <D.30805>; else goto <D.30806>;
      <D.30805>:
      klass->nested_classes_inited = 1;
      <D.30806>:
      mono_loader_lock ();
      D.30800 = BIT_FIELD_REF <*klass, 8, 184>;
      D.30801 = D.30800 & 128;
      if (D.30801 == 0) goto <D.30807>; else goto <D.30808>;
      <D.30807>:
      D.30804 = klass->type_token;
      D.30809 = klass->image;
      D.30810 = mono_metadata_nesting_typedef (D.30809, D.30804, 1);
      i = (int) D.30810;
      goto <D.21286>;
      <D.21287>:
      {
        struct MonoClass * nclass;
        guint32 cols[2];

        try
          {
            D.30811 = i + -1;
            D.30809 = klass->image;
            D.30812 = &D.30809->tables[41];
            mono_metadata_decode_row (D.30812, D.30811, &cols, 2);
            D.30813 = cols[0];
            D.30814 = D.30813 | 33554432;
            D.30809 = klass->image;
            nclass = mono_class_create_from_typedef (D.30809, D.30814, &error);
            D.30815 = mono_error_ok (&error);
            if (D.30815 == 0) goto <D.30816>; else goto <D.30817>;
            <D.30816>:
            mono_error_cleanup (&error);
            D.30818 = i + 1;
            D.30819 = (unsigned int) D.30818;
            D.30804 = klass->type_token;
            D.30809 = klass->image;
            D.30820 = mono_metadata_nesting_typedef (D.30809, D.30804, D.30819);
            i = (int) D.30820;
            // predicted unlikely by continue predictor.
            goto <D.21286>;
            <D.30817>:
            mono_class_alloc_ext (klass);
            D.30821 = klass->ext;
            D.30821 = klass->ext;
            D.30822 = D.30821->nested_classes;
            D.30809 = klass->image;
            D.30823 = g_list_prepend_image (D.30809, D.30822, nclass);
            D.30821->nested_classes = D.30823;
            D.30818 = i + 1;
            D.30819 = (unsigned int) D.30818;
            D.30804 = klass->type_token;
            D.30809 = klass->image;
            D.30824 = mono_metadata_nesting_typedef (D.30809, D.30804, D.30819);
            i = (int) D.30824;
          }
        finally
          {
            cols = {CLOBBER};
          }
      }
      <D.21286>:
      if (i != 0) goto <D.21287>; else goto <D.21288>;
      <D.21288>:
      <D.30808>:
      mono_memory_barrier ();
      klass->nested_classes_inited = 1;
      mono_loader_unlock ();
      <D.30803>:
      D.30825 = *iter;
      if (D.30825 == 0B) goto <D.30826>; else goto <D.30827>;
      <D.30826>:
      D.30821 = klass->ext;
      if (D.30821 != 0B) goto <D.30829>; else goto <D.30828>;
      <D.30829>:
      D.30821 = klass->ext;
      D.30822 = D.30821->nested_classes;
      if (D.30822 != 0B) goto <D.30830>; else goto <D.30828>;
      <D.30830>:
      D.30821 = klass->ext;
      D.30822 = D.30821->nested_classes;
      *iter = D.30822;
      D.30821 = klass->ext;
      D.30822 = D.30821->nested_classes;
      D.30799 = D.30822->data;
      return D.30799;
      <D.30828>:
      D.30799 = 0B;
      return D.30799;
      <D.30827>:
      item = *iter;
      item = item->next;
      if (item != 0B) goto <D.30831>; else goto <D.30832>;
      <D.30831>:
      *iter = item;
      D.30799 = item->data;
      return D.30799;
      <D.30832>:
      D.30799 = 0B;
      return D.30799;
    }
  finally
    {
      error = {CLOBBER};
    }
}


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

  D.30838 = klass->delegate;
  D.30837 = (mono_bool) D.30838;
  return D.30837;
}


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

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


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

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


mono_field_get_type (struct MonoClassField * field)
{
  int D.30844;
  const char * D.30847;
  struct MonoType * D.30848;
  struct MonoError error;
  struct MonoType * type;

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


mono_field_get_type_checked (struct MonoClassField * field, struct MonoError * error)
{
  struct MonoType * D.30851;
  struct MonoType * D.30854;

  mono_error_init (error);
  D.30851 = field->type;
  if (D.30851 == 0B) goto <D.30852>; else goto <D.30853>;
  <D.30852>:
  mono_field_resolve_type (field, error);
  <D.30853>:
  D.30854 = field->type;
  return D.30854;
}


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

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


mono_field_get_flags (struct MonoClassField * field)
{
  struct MonoType * D.30858;
  uint32_t D.30861;
  short unsigned int D.30862;

  D.30858 = field->type;
  if (D.30858 == 0B) goto <D.30859>; else goto <D.30860>;
  <D.30859>:
  D.30861 = mono_field_resolve_flags (field);
  return D.30861;
  <D.30860>:
  D.30858 = field->type;
  D.30862 = D.30858->attrs;
  D.30861 = (uint32_t) D.30862;
  return D.30861;
}


mono_field_resolve_flags (struct MonoClassField * field)
{
  struct MonoClass * iftmp.446;
  struct MonoGenericClass * D.30865;
  int field.447;
  struct MonoClassField * D.30870;
  int D.30871;
  int D.30872;
  struct MonoClassField * D.30875;
  unsigned int field_idx.448;
  unsigned int D.30877;
  guint32 D.30878;
  unsigned int D.30879;
  unsigned int field_idx.449;
  unsigned int D.30881;
  unsigned char D.30882;
  unsigned char D.30883;
  _Bool D.30884;
  long int D.30885;
  long int D.30886;
  struct MonoClass * class;
  struct MonoImage * image;
  struct MonoClass * gtd;
  int field_idx;

  class = field->parent;
  image = class->image;
  D.30865 = class->generic_class;
  if (D.30865 != 0B) goto <D.30866>; else goto <D.30867>;
  <D.30866>:
  iftmp.446 = mono_class_get_generic_type_definition (class);
  goto <D.30868>;
  <D.30867>:
  iftmp.446 = 0B;
  <D.30868>:
  gtd = iftmp.446;
  field.447 = (int) field;
  D.30870 = class->fields;
  D.30871 = (int) D.30870;
  D.30872 = field.447 - D.30871;
  field_idx = D.30872 /[ex] 16;
  if (gtd != 0B) goto <D.30873>; else goto <D.30874>;
  <D.30873>:
  {
    struct MonoClassField * gfield;

    D.30875 = gtd->fields;
    field_idx.448 = (unsigned int) field_idx;
    D.30877 = field_idx.448 * 16;
    gfield = D.30875 + D.30877;
    D.30878 = mono_field_get_flags (gfield);
    return D.30878;
  }
  <D.30874>:
  {
    int idx;

    D.30879 = class->field.first;
    field_idx.449 = (unsigned int) field_idx;
    D.30881 = D.30879 + field_idx.449;
    idx = (int) D.30881;
    D.30882 = BIT_FIELD_REF <*image, 8, 128>;
    D.30883 = D.30882 & 8;
    D.30884 = D.30883 != 0;
    D.30885 = (long int) D.30884;
    D.30886 = __builtin_expect (D.30885, 0);
    if (D.30886 != 0) goto <D.30887>; else goto <D.30888>;
    <D.30887>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "class.c", 10164, "!image->dynamic");
    <D.30888>:
    D.30878 = mono_metadata_decode_table_row_col (image, 4, idx, 0);
    return D.30878;
  }
}


mono_field_get_offset (struct MonoClassField * field)
{
  uint32_t D.30890;
  int D.30891;

  D.30891 = field->offset;
  D.30890 = (uint32_t) D.30891;
  return D.30890;
}


mono_field_get_data (struct MonoClassField * field)
{
  struct MonoType * D.30893;
  short unsigned int D.30894;
  signed short D.30895;
  const char * D.30898;
  int D.30899;
  int D.30900;

  D.30893 = field->type;
  D.30894 = D.30893->attrs;
  D.30895 = (signed short) D.30894;
  if (D.30895 < 0) goto <D.30896>; else goto <D.30897>;
  <D.30896>:
  {
    MonoTypeEnum def_type;

    try
      {
        D.30898 = mono_class_get_field_default_value (field, &def_type);
        return D.30898;
      }
    finally
      {
        def_type = {CLOBBER};
      }
  }
  <D.30897>:
  D.30893 = field->type;
  D.30894 = D.30893->attrs;
  D.30899 = (int) D.30894;
  D.30900 = D.30899 & 256;
  if (D.30900 != 0) goto <D.30901>; else goto <D.30902>;
  <D.30901>:
  D.30898 = mono_field_get_rva (field);
  return D.30898;
  <D.30902>:
  D.30898 = 0B;
  return D.30898;
}


mono_field_get_rva (struct MonoClassField * field)
{
  struct MonoType * D.30905;
  short unsigned int D.30906;
  int D.30907;
  int D.30908;
  _Bool D.30909;
  long int D.30910;
  long int D.30911;
  struct MonoClassExt * D.30916;
  struct MonoFieldDefaultValue * D.30918;
  unsigned int D.30921;
  unsigned int D.30922;
  int D.30923;
  void * D.30924;
  unsigned int field_index.450;
  unsigned int D.30926;
  struct MonoFieldDefaultValue * D.30927;
  const char * D.30928;
  struct MonoImage * D.30931;
  unsigned char D.30932;
  unsigned char D.30933;
  unsigned int D.30936;
  unsigned int field_index.451;
  unsigned int D.30938;
  struct MonoClass * D.30939;
  struct MonoImage * D.30940;
  unsigned int rva.452;
  const char * D.30944;
  const char * D.30945;
  char * D.30946;
  const char * D.30947;
  guint32 rva;
  int field_index;
  struct MonoClass * klass;

  try
    {
      klass = field->parent;
      D.30905 = field->type;
      D.30906 = D.30905->attrs;
      D.30907 = (int) D.30906;
      D.30908 = D.30907 & 256;
      D.30909 = D.30908 == 0;
      D.30910 = (long int) D.30909;
      D.30911 = __builtin_expect (D.30910, 0);
      if (D.30911 != 0) goto <D.30912>; else goto <D.30913>;
      <D.30912>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "class.c", 9062, "field->type->attrs & FIELD_ATTRIBUTE_HAS_FIELD_RVA");
      <D.30913>:
      D.30916 = klass->ext;
      if (D.30916 == 0B) goto <D.30914>; else goto <D.30917>;
      <D.30917>:
      D.30916 = klass->ext;
      D.30918 = D.30916->field_def_values;
      if (D.30918 == 0B) goto <D.30914>; else goto <D.30915>;
      <D.30914>:
      mono_loader_lock ();
      mono_class_alloc_ext (klass);
      D.30916 = klass->ext;
      D.30918 = D.30916->field_def_values;
      if (D.30918 == 0B) goto <D.30919>; else goto <D.30920>;
      <D.30919>:
      D.30916 = klass->ext;
      D.30921 = klass->field.count;
      D.30922 = D.30921 * 8;
      D.30923 = (int) D.30922;
      D.30924 = mono_class_alloc0 (klass, D.30923);
      D.30916->field_def_values = D.30924;
      <D.30920>:
      mono_loader_unlock ();
      <D.30915>:
      field_index = mono_field_get_index (field);
      D.30916 = klass->ext;
      D.30918 = D.30916->field_def_values;
      field_index.450 = (unsigned int) field_index;
      D.30926 = field_index.450 * 8;
      D.30927 = D.30918 + D.30926;
      D.30928 = D.30927->data;
      if (D.30928 == 0B) goto <D.30929>; else goto <D.30930>;
      <D.30929>:
      D.30931 = klass->image;
      D.30932 = BIT_FIELD_REF <*D.30931, 8, 128>;
      D.30933 = D.30932 & 8;
      if (D.30933 == 0) goto <D.30934>; else goto <D.30935>;
      <D.30934>:
      D.30936 = klass->field.first;
      field_index.451 = (unsigned int) field_index;
      D.30938 = D.30936 + field_index.451;
      D.30939 = field->parent;
      D.30940 = D.30939->image;
      mono_metadata_field_info (D.30940, D.30938, 0B, &rva, 0B);
      rva.452 = rva;
      if (rva.452 == 0) goto <D.30942>; else goto <D.30943>;
      <D.30942>:
      D.30939 = field->parent;
      D.30944 = D.30939->name;
      D.30945 = mono_field_get_name (field);
      monoeg_g_log (0B, 16, "field %s in %s should have RVA data, but hasn\'t", D.30945, D.30944);
      <D.30943>:
      D.30916 = klass->ext;
      D.30918 = D.30916->field_def_values;
      field_index.450 = (unsigned int) field_index;
      D.30926 = field_index.450 * 8;
      D.30927 = D.30918 + D.30926;
      rva.452 = rva;
      D.30939 = field->parent;
      D.30940 = D.30939->image;
      D.30946 = mono_image_rva_map (D.30940, rva.452);
      D.30927->data = D.30946;
      <D.30935>:
      <D.30930>:
      D.30916 = klass->ext;
      D.30918 = D.30916->field_def_values;
      field_index.450 = (unsigned int) field_index;
      D.30926 = field_index.450 * 8;
      D.30927 = D.30918 + D.30926;
      D.30947 = D.30927->data;
      return D.30947;
    }
  finally
    {
      rva = {CLOBBER};
    }
}


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

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


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

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


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

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


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

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


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

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


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

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


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

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


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

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


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

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


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

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


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

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


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

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


mono_class_get_method_from_name_flags (struct MonoClass * klass, const char * name, int param_count, int flags)
{
  struct MonoGenericClass * D.30974;
  struct MonoMethod * * D.30977;
  struct MonoClass * D.30980;
  struct MonoGenericContext * D.30983;
  struct MonoMethod * D.30984;
  unsigned int D.30989;
  struct MonoImage * D.30991;
  unsigned char D.30992;
  unsigned char D.30993;
  unsigned int i.453;
  unsigned int D.30998;
  struct MonoMethod * * D.30999;
  const char * D.31002;
  char D.31003;
  char D.31004;
  int D.21405;
  struct MonoMethodSignature * D.31010;
  short unsigned int D.31011;
  int D.31012;
  short unsigned int D.31013;
  int D.31014;
  int D.31015;
  unsigned int i.454;
  unsigned int D.31019;
  struct MonoMethod * res;
  int i;

  res = 0B;
  mono_class_init (klass);
  D.30974 = klass->generic_class;
  if (D.30974 != 0B) goto <D.30975>; else goto <D.30976>;
  <D.30975>:
  D.30977 = klass->methods;
  if (D.30977 == 0B) goto <D.30978>; else goto <D.30979>;
  <D.30978>:
  D.30974 = klass->generic_class;
  D.30980 = D.30974->container_class;
  res = mono_class_get_method_from_name_flags (D.30980, name, param_count, flags);
  if (res != 0B) goto <D.30981>; else goto <D.30982>;
  <D.30981>:
  D.30983 = mono_class_get_context (klass);
  res = mono_class_inflate_generic_method_full (res, klass, D.30983);
  <D.30982>:
  D.30984 = res;
  return D.30984;
  <D.30979>:
  <D.30976>:
  D.30977 = klass->methods;
  if (D.30977 != 0B) goto <D.30985>; else goto <D.30988>;
  <D.30988>:
  D.30989 = klass->type_token;
  if (D.30989 == 0) goto <D.30985>; else goto <D.30990>;
  <D.30990>:
  D.30991 = klass->image;
  D.30992 = BIT_FIELD_REF <*D.30991, 8, 128>;
  D.30993 = D.30992 & 8;
  if (D.30993 != 0) goto <D.30985>; else goto <D.30994>;
  <D.30994>:
  D.30974 = klass->generic_class;
  if (D.30974 != 0B) goto <D.30985>; else goto <D.30986>;
  <D.30985>:
  mono_class_setup_methods (klass);
  D.30977 = klass->methods;
  if (D.30977 == 0B) goto <D.30995>; else goto <D.30996>;
  <D.30995>:
  D.30984 = 0B;
  return D.30984;
  <D.30996>:
  i = 0;
  goto <D.21408>;
  <D.21407>:
  {
    struct MonoMethod * method;

    D.30977 = klass->methods;
    i.453 = (unsigned int) i;
    D.30998 = i.453 * 4;
    D.30999 = D.30977 + D.30998;
    method = *D.30999;
    D.31002 = method->name;
    D.31003 = *D.31002;
    D.31004 = *name;
    if (D.31003 == D.31004) goto <D.31005>; else goto <D.31006>;
    <D.31005>:
    {
      size_t __s1_len;
      size_t __s2_len;

      D.31002 = method->name;
      D.21405 = __builtin_strcmp (name, D.31002);
    }
    if (D.21405 == 0) goto <D.31007>; else goto <D.31008>;
    <D.31007>:
    if (param_count == -1) goto <D.31000>; else goto <D.31009>;
    <D.31009>:
    D.31010 = mono_method_signature (method);
    D.31011 = D.31010->param_count;
    D.31012 = (int) D.31011;
    if (D.31012 == param_count) goto <D.31000>; else goto <D.31001>;
    <D.31000>:
    D.31013 = method->flags;
    D.31014 = (int) D.31013;
    D.31015 = D.31014 & flags;
    if (D.31015 == flags) goto <D.31016>; else goto <D.31017>;
    <D.31016>:
    res = method;
    goto <D.21406>;
    <D.31017>:
    <D.31001>:
    <D.31008>:
    <D.31006>:
  }
  i = i + 1;
  <D.21408>:
  i.454 = (unsigned int) i;
  D.31019 = klass->method.count;
  if (i.454 < D.31019) goto <D.21407>; else goto <D.21406>;
  <D.21406>:
  goto <D.30987>;
  <D.30986>:
  res = find_method_in_metadata (klass, name, param_count, flags);
  <D.30987>:
  D.30984 = res;
  return D.30984;
}


mono_class_set_failure (struct MonoClass * klass, guint32 ex_type, void * ex_data)
{
  unsigned char D.31021;
  gboolean D.31024;
  unsigned char D.31025;
  struct MonoImage * D.31028;

  D.31021 = klass->exception_type;
  if (D.31021 != 0) goto <D.31022>; else goto <D.31023>;
  <D.31022>:
  D.31024 = 0;
  return D.31024;
  <D.31023>:
  mono_loader_lock ();
  D.31025 = (unsigned char) ex_type;
  klass->exception_type = D.31025;
  if (ex_data != 0B) goto <D.31026>; else goto <D.31027>;
  <D.31026>:
  D.31028 = klass->image;
  mono_image_property_insert (D.31028, klass, 0, ex_data);
  <D.31027>:
  mono_loader_unlock ();
  D.31024 = 1;
  return D.31024;
}


mono_class_get_exception_data (struct MonoClass * klass)
{
  void * D.31030;
  struct MonoImage * D.31031;

  D.31031 = klass->image;
  D.31030 = mono_image_property_lookup (D.31031, klass, 0);
  return D.31030;
}


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);
}


mono_classes_cleanup ()
{
  struct MonoBitSet * global_interface_bitset.455;

  global_interface_bitset.455 = global_interface_bitset;
  if (global_interface_bitset.455 != 0B) goto <D.31034>; else goto <D.31035>;
  <D.31034>:
  global_interface_bitset.455 = global_interface_bitset;
  mono_bitset_free (global_interface_bitset.455);
  <D.31035>:
  global_interface_bitset = 0B;
}


mono_class_get_exception_for_failure (struct MonoClass * klass)
{
  unsigned char D.31036;
  int D.31037;
  guint32 iftmp.456;
  struct MonoImage * D.31042;
  struct MonoAssembly * D.31043;
  struct MonoReflectionAssembly * D.31044;
  struct MonoType * D.31045;
  struct MonoReflectionType * D.31046;
  void * iftmp.457;
  struct MonoMethod * D.31051;
  struct MonoException * D.31052;
  char * iftmp.458;
  struct MonoAssembly * D.31054;
  struct MonoAssemblyName * D.31057;
  struct MonoDomain * D.31059;
  unsigned int D.31060;
  sizetype D.31061;
  unsigned int D.31062;
  sizetype D.31063;
  unsigned int D.31064;
  sizetype D.31065;
  struct MonoDomain * D.31066;
  struct MonoString * D.31067;
  void * exception_data;

  exception_data = mono_class_get_exception_data (klass);
  D.31036 = klass->exception_type;
  D.31037 = (int) D.31036;
  switch (D.31037) <default: <D.21451>, case 2: <D.21427>, case 5: <D.21439>, case 6: <D.21442>, case 7: <D.21434>, case 8: <D.21445>, case 12: <D.21450>>
  <D.21427>:
  {
    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.31039>; else goto <D.31040>;
        <D.31039>:
        iftmp.456 = 2;
        goto <D.31041>;
        <D.31040>:
        iftmp.456 = 1;
        <D.31041>:
        error = iftmp.456;
        exc = 0B;
        args[0] = &error;
        D.31042 = klass->image;
        D.31043 = mono_image_get_assembly (D.31042);
        D.31044 = mono_assembly_get_object (domain, D.31043);
        args[1] = D.31044;
        D.31045 = &klass->byval_arg;
        D.31046 = mono_type_get_object (domain, D.31045);
        args[2] = D.31046;
        if (method != 0B) goto <D.31048>; else goto <D.31049>;
        <D.31048>:
        iftmp.457 = mono_method_get_object (domain, method, 0B);
        goto <D.31050>;
        <D.31049>:
        iftmp.457 = 0B;
        <D.31050>:
        args[3] = iftmp.457;
        D.31051 = secman->inheritsecurityexception;
        mono_runtime_invoke (D.31051, 0B, &args, &exc);
        D.31052 = exc;
        return D.31052;
      }
    finally
      {
        error = {CLOBBER};
        exc = {CLOBBER};
        args = {CLOBBER};
      }
  }
  <D.21434>:
  {
    struct MonoString * name;
    struct MonoException * ex;
    char * str;
    char * astr;

    str = mono_type_get_full_name (klass);
    D.31042 = klass->image;
    D.31054 = D.31042->assembly;
    if (D.31054 != 0B) goto <D.31055>; else goto <D.31056>;
    <D.31055>:
    D.31042 = klass->image;
    D.31054 = D.31042->assembly;
    D.31057 = &D.31054->aname;
    iftmp.458 = mono_stringify_assembly_name (D.31057);
    goto <D.31058>;
    <D.31056>:
    iftmp.458 = 0B;
    <D.31058>:
    astr = iftmp.458;
    D.31059 = mono_domain_get ();
    name = mono_string_new (D.31059, str);
    monoeg_g_free (str);
    ex = mono_get_exception_type_load (name, astr);
    monoeg_g_free (astr);
    D.31052 = ex;
    return D.31052;
  }
  <D.21439>:
  {
    char * class_name;
    char * assembly_name;

    class_name = exception_data;
    D.31060 = strlen (class_name);
    D.31061 = D.31060 + 1;
    assembly_name = class_name + D.31061;
    D.31052 = mono_get_exception_missing_method (class_name, assembly_name);
    return D.31052;
  }
  <D.21442>:
  {
    char * class_name;
    char * member_name;

    class_name = exception_data;
    D.31062 = strlen (class_name);
    D.31063 = D.31062 + 1;
    member_name = class_name + D.31063;
    D.31052 = mono_get_exception_missing_field (class_name, member_name);
    return D.31052;
  }
  <D.21445>:
  {
    char * msg_format;
    char * assembly_name;
    char * msg;
    struct MonoException * ex;

    msg_format = exception_data;
    D.31064 = strlen (msg_format);
    D.31065 = D.31064 + 1;
    assembly_name = msg_format + D.31065;
    msg = monoeg_g_strdup_printf (msg_format, assembly_name);
    D.31066 = mono_domain_get ();
    D.31067 = mono_string_new (D.31066, assembly_name);
    ex = mono_get_exception_file_not_found2 (msg, D.31067);
    monoeg_g_free (msg);
    D.31052 = ex;
    return D.31052;
  }
  <D.21450>:
  D.31052 = mono_get_exception_bad_image_format (exception_data);
  return D.31052;
  <D.21451>:
  {
    struct MonoLoaderError * error;
    struct MonoException * ex;

    error = mono_loader_get_last_error ();
    if (error != 0B) goto <D.31068>; else goto <D.31069>;
    <D.31068>:
    ex = mono_loader_error_prepare_exception (error);
    D.31052 = ex;
    return D.31052;
    <D.31069>:
    D.31052 = 0B;
    return D.31052;
  }
}


mono_class_get_generic_type_definition (struct MonoClass * klass)
{
  struct MonoClass * D.31072;
  struct MonoClass * iftmp.459;
  struct MonoGenericClass * D.31074;

  D.31074 = klass->generic_class;
  if (D.31074 != 0B) goto <D.31075>; else goto <D.31076>;
  <D.31075>:
  D.31074 = klass->generic_class;
  iftmp.459 = D.31074->container_class;
  goto <D.31077>;
  <D.31076>:
  iftmp.459 = klass;
  <D.31077>:
  D.31072 = iftmp.459;
  return D.31072;
}


mono_class_has_parent_and_ignore_generics (struct MonoClass * klass, struct MonoClass * parent)
{
  struct MonoClass * * D.31079;
  unsigned int i.460;
  unsigned int D.31081;
  struct MonoClass * * D.31082;
  struct MonoClass * D.31083;
  struct MonoClass * D.31084;
  gboolean D.31087;
  short unsigned int D.31088;
  int D.31089;
  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.21469>;
  <D.21468>:
  D.31079 = klass->supertypes;
  i.460 = (unsigned int) i;
  D.31081 = i.460 * 4;
  D.31082 = D.31079 + D.31081;
  D.31083 = *D.31082;
  D.31084 = mono_class_get_generic_type_definition (D.31083);
  if (D.31084 == parent) goto <D.31085>; else goto <D.31086>;
  <D.31085>:
  D.31087 = 1;
  return D.31087;
  <D.31086>:
  i = i + 1;
  <D.21469>:
  D.31088 = klass->idepth;
  D.31089 = (int) D.31088;
  if (D.31089 > i) goto <D.21468>; else goto <D.21470>;
  <D.21470>:
  D.31087 = 0;
  return D.31087;
}


mono_method_can_access_field (struct MonoMethod * method, struct MonoClassField * field)
{
  struct MonoType * D.31091;
  short unsigned int D.31092;
  int D.31093;
  int D.31094;
  struct MonoClass * D.31095;
  struct MonoClass * D.31096;
  struct MonoType * D.31099;
  short unsigned int D.31100;
  int D.31101;
  int D.31102;
  mono_bool D.31105;
  int can;

  D.31091 = mono_field_get_type (field);
  D.31092 = D.31091->attrs;
  D.31093 = (int) D.31092;
  D.31094 = D.31093 & 7;
  D.31095 = field->parent;
  D.31096 = method->klass;
  can = can_access_member (D.31096, D.31095, 0B, D.31094);
  if (can == 0) goto <D.31097>; else goto <D.31098>;
  <D.31097>:
  {
    struct MonoClass * nested;

    D.31096 = method->klass;
    nested = D.31096->nested_in;
    goto <D.21552>;
    <D.21551>:
    D.31099 = mono_field_get_type (field);
    D.31100 = D.31099->attrs;
    D.31101 = (int) D.31100;
    D.31102 = D.31101 & 7;
    D.31095 = field->parent;
    can = can_access_member (nested, D.31095, 0B, D.31102);
    if (can != 0) goto <D.31103>; else goto <D.31104>;
    <D.31103>:
    D.31105 = 1;
    return D.31105;
    <D.31104>:
    nested = nested->nested_in;
    <D.21552>:
    if (nested != 0B) goto <D.21551>; else goto <D.21553>;
    <D.21553>:
  }
  <D.31098>:
  D.31105 = can;
  return D.31105;
}


can_access_member (struct MonoClass * access_klass, struct MonoClass * member_klass, struct MonoClass * context_klass, int access_level)
{
  struct MonoImage * D.31107;
  struct MonoAssembly * D.31108;
  unsigned char D.31111;
  gboolean D.31114;
  struct MonoGenericClass * D.31118;
  struct MonoClass * D.31120;
  struct MonoGenericContainer * D.31121;
  int D.31127;
  struct MonoImage * D.31130;
  _Bool D.31131;
  _Bool D.31132;
  int D.31133;
  struct MonoAssembly * D.31136;
  int D.31137;
  int D.31140;
  int D.31143;
  struct MonoClass * member_generic_def;

  D.31107 = access_klass->image;
  D.31108 = D.31107->assembly;
  if (D.31108 != 0B) goto <D.31109>; else goto <D.31110>;
  <D.31109>:
  D.31107 = access_klass->image;
  D.31108 = D.31107->assembly;
  D.31111 = D.31108->corlib_internal;
  if (D.31111 != 0) goto <D.31112>; else goto <D.31113>;
  <D.31112>:
  D.31114 = 1;
  return D.31114;
  <D.31113>:
  <D.31110>:
  D.31118 = access_klass->generic_class;
  if (D.31118 != 0B) goto <D.31119>; else goto <D.31115>;
  <D.31119>:
  D.31118 = access_klass->generic_class;
  D.31120 = D.31118->container_class;
  if (D.31120 != 0B) goto <D.31116>; else goto <D.31115>;
  <D.31115>:
  D.31121 = access_klass->generic_container;
  if (D.31121 != 0B) goto <D.31116>; else goto <D.31117>;
  <D.31116>:
  member_generic_def = get_generic_definition_class (member_klass);
  if (member_generic_def != 0B) goto <D.31122>; else goto <D.31123>;
  <D.31122>:
  {
    struct MonoClass * access_container;

    D.31121 = access_klass->generic_container;
    if (D.31121 != 0B) goto <D.31124>; else goto <D.31125>;
    <D.31124>:
    access_container = access_klass;
    goto <D.31126>;
    <D.31125>:
    D.31118 = access_klass->generic_class;
    access_container = D.31118->container_class;
    <D.31126>:
    D.31127 = can_access_member (access_container, member_generic_def, context_klass, access_level);
    if (D.31127 != 0) goto <D.31128>; else goto <D.31129>;
    <D.31128>:
    D.31114 = 1;
    return D.31114;
    <D.31129>:
  }
  <D.31123>:
  <D.31117>:
  switch (access_level) <default: <D.31146>, case 0: <D.21538>, case 1: <D.21539>, case 2: <D.21540>, case 3: <D.21541>, case 4: <D.21542>, case 5: <D.21543>, case 6: <D.21544>>
  <D.21538>:
  D.31107 = access_klass->image;
  D.31130 = member_klass->image;
  D.31131 = D.31107 == D.31130;
  D.31114 = (gboolean) D.31131;
  return D.31114;
  <D.21539>:
  D.31132 = access_klass == member_klass;
  D.31114 = (gboolean) D.31132;
  return D.31114;
  <D.21540>:
  D.31133 = is_valid_family_access (access_klass, member_klass, context_klass);
  if (D.31133 != 0) goto <D.31134>; else goto <D.31135>;
  <D.31134>:
  D.31130 = member_klass->image;
  D.31136 = D.31130->assembly;
  D.31107 = access_klass->image;
  D.31108 = D.31107->assembly;
  D.31137 = can_access_internals (D.31108, D.31136);
  if (D.31137 != 0) goto <D.31138>; else goto <D.31139>;
  <D.31138>:
  D.31114 = 1;
  return D.31114;
  <D.31139>:
  <D.31135>:
  D.31114 = 0;
  return D.31114;
  <D.21541>:
  D.31130 = member_klass->image;
  D.31136 = D.31130->assembly;
  D.31107 = access_klass->image;
  D.31108 = D.31107->assembly;
  D.31114 = can_access_internals (D.31108, D.31136);
  return D.31114;
  <D.21542>:
  D.31140 = is_valid_family_access (access_klass, member_klass, context_klass);
  if (D.31140 != 0) goto <D.31141>; else goto <D.31142>;
  <D.31141>:
  D.31114 = 1;
  return D.31114;
  <D.31142>:
  D.31114 = 0;
  return D.31114;
  <D.21543>:
  D.31143 = is_valid_family_access (access_klass, member_klass, context_klass);
  if (D.31143 != 0) goto <D.31144>; else goto <D.31145>;
  <D.31144>:
  D.31114 = 1;
  return D.31114;
  <D.31145>:
  D.31130 = member_klass->image;
  D.31136 = D.31130->assembly;
  D.31107 = access_klass->image;
  D.31108 = D.31107->assembly;
  D.31114 = can_access_internals (D.31108, D.31136);
  return D.31114;
  <D.21544>:
  D.31114 = 1;
  return D.31114;
  <D.31146>:
  D.31114 = 0;
  return D.31114;
}


get_generic_definition_class (struct MonoClass * klass)
{
  struct MonoGenericClass * D.31148;
  struct MonoClass * D.31151;
  struct MonoClass * D.31154;

  goto <D.21499>;
  <D.21498>:
  D.31148 = klass->generic_class;
  if (D.31148 != 0B) goto <D.31149>; else goto <D.31150>;
  <D.31149>:
  D.31148 = klass->generic_class;
  D.31151 = D.31148->container_class;
  if (D.31151 != 0B) goto <D.31152>; else goto <D.31153>;
  <D.31152>:
  D.31148 = klass->generic_class;
  D.31154 = D.31148->container_class;
  return D.31154;
  <D.31153>:
  <D.31150>:
  klass = klass->parent;
  <D.21499>:
  if (klass != 0B) goto <D.21498>; else goto <D.21500>;
  <D.21500>:
  D.31154 = 0B;
  return D.31154;
}


is_valid_family_access (struct MonoClass * access_klass, struct MonoClass * member_klass, struct MonoClass * context_klass)
{
  int D.31156;
  gboolean D.31159;
  int D.31164;

  D.31156 = mono_class_has_parent_and_ignore_generics (access_klass, member_klass);
  if (D.31156 == 0) goto <D.31157>; else goto <D.31158>;
  <D.31157>:
  D.31159 = 0;
  return D.31159;
  <D.31158>:
  if (context_klass == 0B) goto <D.31160>; else goto <D.31161>;
  <D.31160>:
  D.31159 = 1;
  return D.31159;
  <D.31161>:
  if (access_klass != member_klass) goto <D.31162>; else goto <D.31163>;
  <D.31162>:
  D.31164 = mono_class_has_parent_and_ignore_generics (context_klass, access_klass);
  if (D.31164 == 0) goto <D.31165>; else goto <D.31166>;
  <D.31165>:
  D.31159 = 0;
  return D.31159;
  <D.31166>:
  <D.31163>:
  D.31159 = 1;
  return D.31159;
}


can_access_internals (struct MonoAssembly * accessing, struct MonoAssembly * accessed)
{
  gboolean D.31170;
  _Bool D.31171;
  _Bool D.31172;
  _Bool D.31173;
  <unnamed type> D.31176;
  struct MonoImage * D.31179;
  struct MonoImage * D.31180;
  int D.31181;
  const char * D.31184;
  int D.21491;
  const char * D.31187;
  unsigned char D.31190;
  unsigned char D.31193;
  mono_byte[17] * D.31196;
  mono_byte[17] * D.31197;
  int D.31198;
  struct GSList * tmp;

  if (accessing == accessed) goto <D.31168>; else goto <D.31169>;
  <D.31168>:
  D.31170 = 1;
  return D.31170;
  <D.31169>:
  D.31171 = accessed == 0B;
  D.31172 = accessing == 0B;
  D.31173 = D.31171 | D.31172;
  if (D.31173 != 0) goto <D.31174>; else goto <D.31175>;
  <D.31174>:
  D.31170 = 0;
  return D.31170;
  <D.31175>:
  D.31176 = mono_security_get_mode ();
  if (D.31176 == 1) goto <D.31177>; else goto <D.31178>;
  <D.31177>:
  D.31179 = accessed->image;
  D.31180 = accessing->image;
  D.31181 = mono_security_core_clr_can_access_internals (D.31180, D.31179);
  if (D.31181 == 0) goto <D.31182>; else goto <D.31183>;
  <D.31182>:
  D.31170 = 0;
  return D.31170;
  <D.31183>:
  <D.31178>:
  mono_assembly_load_friends (accessed);
  tmp = accessed->friend_assembly_names;
  goto <D.21493>;
  <D.21492>:
  {
    struct MonoAssemblyName * friend;

    friend = tmp->data;
    D.31184 = friend->name;
    if (D.31184 == 0B) goto <D.31185>; else goto <D.31186>;
    <D.31185>:
    // predicted unlikely by continue predictor.
    goto <D.21482>;
    <D.31186>:
    {
      size_t __s1_len;
      size_t __s2_len;

      D.31184 = friend->name;
      D.31187 = accessing->aname.name;
      D.21491 = __builtin_strcmp (D.31187, D.31184);
    }
    if (D.21491 != 0) goto <D.31188>; else goto <D.31189>;
    <D.31188>:
    // predicted unlikely by continue predictor.
    goto <D.21482>;
    <D.31189>:
    D.31190 = friend->public_key_token[0];
    if (D.31190 != 0) goto <D.31191>; else goto <D.31192>;
    <D.31191>:
    D.31193 = accessing->aname.public_key_token[0];
    if (D.31193 == 0) goto <D.31194>; else goto <D.31195>;
    <D.31194>:
    // predicted unlikely by continue predictor.
    goto <D.21482>;
    <D.31195>:
    D.31196 = &accessing->aname.public_key_token;
    D.31197 = &friend->public_key_token;
    D.31198 = mono_public_tokens_are_equal (D.31197, D.31196);
    if (D.31198 == 0) goto <D.31199>; else goto <D.31200>;
    <D.31199>:
    // predicted unlikely by continue predictor.
    goto <D.21482>;
    <D.31200>:
    <D.31192>:
    D.31170 = 1;
    return D.31170;
  }
  <D.21482>:
  tmp = tmp->next;
  <D.21493>:
  if (tmp != 0B) goto <D.21492>; else goto <D.21494>;
  <D.21494>:
  D.31170 = 0;
  return D.31170;
}


mono_method_can_access_method (struct MonoMethod * method, struct MonoMethod * called)
{
  short unsigned int D.31202;
  int D.31203;
  int D.31204;
  struct MonoClass * D.31205;
  struct MonoClass * D.31206;
  mono_bool D.31211;
  unsigned int D.31212;
  unsigned int D.31213;
  int can;

  D.31202 = called->flags;
  D.31203 = (int) D.31202;
  D.31204 = D.31203 & 7;
  D.31205 = called->klass;
  D.31206 = method->klass;
  can = can_access_member (D.31206, D.31205, 0B, D.31204);
  if (can == 0) goto <D.31207>; else goto <D.31208>;
  <D.31207>:
  {
    struct MonoClass * nested;

    D.31206 = method->klass;
    nested = D.31206->nested_in;
    goto <D.21561>;
    <D.21560>:
    D.31202 = called->flags;
    D.31203 = (int) D.31202;
    D.31204 = D.31203 & 7;
    D.31205 = called->klass;
    can = can_access_member (nested, D.31205, 0B, D.31204);
    if (can != 0) goto <D.31209>; else goto <D.31210>;
    <D.31209>:
    D.31211 = 1;
    return D.31211;
    <D.31210>:
    nested = nested->nested_in;
    <D.21561>:
    if (nested != 0B) goto <D.21560>; else goto <D.21562>;
    <D.21562>:
  }
  <D.31208>:
  D.31202 = called->flags;
  D.31212 = (unsigned int) D.31202;
  D.31213 = D.31212 & 96;
  if (D.31213 == 96) goto <D.31214>; else goto <D.31215>;
  <D.31214>:
  D.31211 = 1;
  return D.31211;
  <D.31215>:
  D.31211 = can;
  return D.31211;
}


mono_method_can_access_method_full (struct MonoMethod * method, struct MonoMethod * called, struct MonoClass * context_klass)
{
  short unsigned int D.31217;
  int D.31218;
  int D.31219;
  gboolean D.31225;
  unsigned char D.31231;
  unsigned char D.31232;
  struct MonoGenericInst * D.31235;
  int D.31238;
  struct MonoClass * access_class;
  struct MonoClass * member_class;
  int can;

  access_class = method->klass;
  member_class = called->klass;
  D.31217 = called->flags;
  D.31218 = (int) D.31217;
  D.31219 = D.31218 & 7;
  can = can_access_member (access_class, member_class, context_klass, D.31219);
  if (can == 0) goto <D.31220>; else goto <D.31221>;
  <D.31220>:
  {
    struct MonoClass * nested;

    nested = access_class->nested_in;
    goto <D.21574>;
    <D.21573>:
    D.31217 = called->flags;
    D.31218 = (int) D.31217;
    D.31219 = D.31218 & 7;
    can = can_access_member (nested, member_class, context_klass, D.31219);
    if (can != 0) goto <D.21572>; else goto <D.31222>;
    <D.31222>:
    nested = nested->nested_in;
    <D.21574>:
    if (nested != 0B) goto <D.21573>; else goto <D.21572>;
    <D.21572>:
  }
  <D.31221>:
  if (can == 0) goto <D.31223>; else goto <D.31224>;
  <D.31223>:
  D.31225 = 0;
  return D.31225;
  <D.31224>:
  can = can_access_type (access_class, member_class);
  if (can == 0) goto <D.31226>; else goto <D.31227>;
  <D.31226>:
  {
    struct MonoClass * nested;

    nested = access_class->nested_in;
    goto <D.21578>;
    <D.21577>:
    can = can_access_type (nested, member_class);
    if (can != 0) goto <D.21576>; else goto <D.31228>;
    <D.31228>:
    nested = nested->nested_in;
    <D.21578>:
    if (nested != 0B) goto <D.21577>; else goto <D.21576>;
    <D.21576>:
  }
  <D.31227>:
  if (can == 0) goto <D.31229>; else goto <D.31230>;
  <D.31229>:
  D.31225 = 0;
  return D.31225;
  <D.31230>:
  D.31231 = BIT_FIELD_REF <*called, 8, 168>;
  D.31232 = D.31231 & 16;
  if (D.31232 != 0) goto <D.31233>; else goto <D.31234>;
  <D.31233>:
  {
    struct MonoMethodInflated * infl;

    infl = called;
    D.31235 = infl->context.method_inst;
    if (D.31235 != 0B) goto <D.31236>; else goto <D.31237>;
    <D.31236>:
    D.31235 = infl->context.method_inst;
    D.31238 = can_access_instantiation (access_class, D.31235);
    if (D.31238 == 0) goto <D.31239>; else goto <D.31240>;
    <D.31239>:
    D.31225 = 0;
    return D.31225;
    <D.31240>:
    <D.31237>:
  }
  <D.31234>:
  D.31225 = 1;
  return D.31225;
}


can_access_type (struct MonoClass * access_klass, struct MonoClass * member_klass)
{
  struct MonoImage * D.31242;
  struct MonoAssembly * D.31243;
  unsigned char D.31246;
  gboolean D.31249;
  struct MonoClass * D.31250;
  unsigned char D.31253;
  unsigned char D.31254;
  struct MonoClass * D.31257;
  unsigned char D.31260;
  unsigned char D.31261;
  unsigned int D.31264;
  int D.31265;
  unsigned char D.31266;
  _Bool D.31267;
  _Bool D.31268;
  _Bool D.31269;
  struct MonoGenericClass * D.31272;
  struct MonoGenericInst * D.31275;
  int D.31276;
  int D.31281;
  struct MonoClass * D.31283;
  int D.31285;
  struct MonoClass * D.31286;
  int D.31289;
  unsigned int access_level.461;
  unsigned int D.31293;
  struct MonoImage * D.31298;
  struct MonoAssembly * D.31299;
  int iftmp.462;
  struct MonoImage * D.31303;
  struct MonoAssembly * D.31304;
  int D.31305;
  int D.31307;
  int iftmp.463;
  int D.31313;
  int D.31315;
  int access_level;

  D.31242 = access_klass->image;
  D.31243 = D.31242->assembly;
  if (D.31243 != 0B) goto <D.31244>; else goto <D.31245>;
  <D.31244>:
  D.31242 = access_klass->image;
  D.31243 = D.31242->assembly;
  D.31246 = D.31243->corlib_internal;
  if (D.31246 != 0) goto <D.31247>; else goto <D.31248>;
  <D.31247>:
  D.31249 = 1;
  return D.31249;
  <D.31248>:
  <D.31245>:
  D.31250 = access_klass->element_class;
  if (D.31250 != 0B) goto <D.31251>; else goto <D.31252>;
  <D.31251>:
  D.31253 = BIT_FIELD_REF <*access_klass, 8, 160>;
  D.31254 = D.31253 & 16;
  if (D.31254 == 0) goto <D.31255>; else goto <D.31256>;
  <D.31255>:
  access_klass = access_klass->element_class;
  <D.31256>:
  <D.31252>:
  D.31257 = member_klass->element_class;
  if (D.31257 != 0B) goto <D.31258>; else goto <D.31259>;
  <D.31258>:
  D.31260 = BIT_FIELD_REF <*member_klass, 8, 160>;
  D.31261 = D.31260 & 16;
  if (D.31261 == 0) goto <D.31262>; else goto <D.31263>;
  <D.31262>:
  member_klass = member_klass->element_class;
  <D.31263>:
  <D.31259>:
  D.31264 = member_klass->flags;
  D.31265 = (int) D.31264;
  access_level = D.31265 & 7;
  D.31266 = member_klass->byval_arg.type;
  D.31267 = D.31266 == 19;
  D.31268 = D.31266 == 30;
  D.31269 = D.31267 | D.31268;
  if (D.31269 != 0) goto <D.31270>; else goto <D.31271>;
  <D.31270>:
  D.31249 = 1;
  return D.31249;
  <D.31271>:
  D.31272 = member_klass->generic_class;
  if (D.31272 != 0B) goto <D.31273>; else goto <D.31274>;
  <D.31273>:
  D.31272 = member_klass->generic_class;
  D.31275 = D.31272->context.class_inst;
  D.31276 = can_access_instantiation (access_klass, D.31275);
  if (D.31276 == 0) goto <D.31277>; else goto <D.31278>;
  <D.31277>:
  D.31249 = 0;
  return D.31249;
  <D.31278>:
  <D.31274>:
  D.31281 = is_nesting_type (access_klass, member_klass);
  if (D.31281 != 0) goto <D.31279>; else goto <D.31282>;
  <D.31282>:
  D.31283 = access_klass->nested_in;
  if (D.31283 != 0B) goto <D.31284>; else goto <D.31280>;
  <D.31284>:
  D.31283 = access_klass->nested_in;
  D.31285 = is_nesting_type (D.31283, member_klass);
  if (D.31285 != 0) goto <D.31279>; else goto <D.31280>;
  <D.31279>:
  D.31249 = 1;
  return D.31249;
  <D.31280>:
  D.31286 = member_klass->nested_in;
  if (D.31286 != 0B) goto <D.31287>; else goto <D.31288>;
  <D.31287>:
  D.31286 = member_klass->nested_in;
  D.31289 = can_access_type (access_klass, D.31286);
  if (D.31289 == 0) goto <D.31290>; else goto <D.31291>;
  <D.31290>:
  D.31249 = 0;
  return D.31249;
  <D.31291>:
  <D.31288>:
  access_level.461 = (unsigned int) access_level;
  D.31293 = access_level.461 + 4294967293;
  if (D.31293 <= 4) goto <D.31294>; else goto <D.31295>;
  <D.31294>:
  D.31286 = member_klass->nested_in;
  if (D.31286 == 0B) goto <D.31296>; else goto <D.31297>;
  <D.31296>:
  D.31249 = 0;
  return D.31249;
  <D.31297>:
  <D.31295>:
  switch (access_level) <default: <D.31316>, case 0: <D.21522>, case 1: <D.21523>, case 2: <D.21524>, case 3: <D.21525>, case 4: <D.21526>, case 5: <D.21527>, case 6: <D.21528>, case 7: <D.21529>>
  <D.21522>:
  D.31298 = member_klass->image;
  D.31299 = D.31298->assembly;
  D.31242 = access_klass->image;
  D.31243 = D.31242->assembly;
  D.31249 = can_access_internals (D.31243, D.31299);
  return D.31249;
  <D.21523>:
  D.31249 = 1;
  return D.31249;
  <D.21524>:
  D.31249 = 1;
  return D.31249;
  <D.21525>:
  D.31249 = is_nesting_type (member_klass, access_klass);
  return D.31249;
  <D.21526>:
  D.31286 = member_klass->nested_in;
  D.31249 = mono_class_has_parent_and_ignore_generics (access_klass, D.31286);
  return D.31249;
  <D.21527>:
  D.31298 = member_klass->image;
  D.31299 = D.31298->assembly;
  D.31242 = access_klass->image;
  D.31243 = D.31242->assembly;
  D.31249 = can_access_internals (D.31243, D.31299);
  return D.31249;
  <D.21528>:
  D.31286 = member_klass->nested_in;
  D.31303 = D.31286->image;
  D.31304 = D.31303->assembly;
  D.31242 = access_klass->image;
  D.31243 = D.31242->assembly;
  D.31305 = can_access_internals (D.31243, D.31304);
  if (D.31305 != 0) goto <D.31306>; else goto <D.31301>;
  <D.31306>:
  D.31286 = member_klass->nested_in;
  D.31307 = mono_class_has_parent_and_ignore_generics (access_klass, D.31286);
  if (D.31307 != 0) goto <D.31308>; else goto <D.31301>;
  <D.31308>:
  iftmp.462 = 1;
  goto <D.31302>;
  <D.31301>:
  iftmp.462 = 0;
  <D.31302>:
  D.31249 = iftmp.462;
  return D.31249;
  <D.21529>:
  D.31286 = member_klass->nested_in;
  D.31303 = D.31286->image;
  D.31304 = D.31303->assembly;
  D.31242 = access_klass->image;
  D.31243 = D.31242->assembly;
  D.31313 = can_access_internals (D.31243, D.31304);
  if (D.31313 != 0) goto <D.31310>; else goto <D.31314>;
  <D.31314>:
  D.31286 = member_klass->nested_in;
  D.31315 = mono_class_has_parent_and_ignore_generics (access_klass, D.31286);
  if (D.31315 != 0) goto <D.31310>; else goto <D.31311>;
  <D.31310>:
  iftmp.463 = 1;
  goto <D.31312>;
  <D.31311>:
  iftmp.463 = 0;
  <D.31312>:
  D.31249 = iftmp.463;
  return D.31249;
  <D.31316>:
  D.31249 = 0;
  return D.31249;
}


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

  outer_klass = mono_class_get_generic_type_definition (outer_klass);
  inner_klass = mono_class_get_generic_type_definition (inner_klass);
  <D.21458>:
  if (outer_klass == inner_klass) goto <D.31318>; else goto <D.31319>;
  <D.31318>:
  D.31320 = 1;
  return D.31320;
  <D.31319>:
  inner_klass = inner_klass->nested_in;
  if (inner_klass != 0B) goto <D.21458>; else goto <D.21459>;
  <D.21459>:
  D.31320 = 0;
  return D.31320;
}


can_access_instantiation (struct MonoClass * access_klass, struct MonoGenericInst * ginst)
{
  unsigned char D.31322;
  int D.31323;
  struct MonoClass * D.31324;
  int D.31325;
  gboolean D.31328;
  struct MonoArrayType * D.31329;
  struct MonoClass * D.31330;
  int D.31331;
  struct MonoType * D.31334;
  struct MonoClass * D.31335;
  int D.31336;
  struct MonoClass * D.31339;
  int D.31340;
  <unnamed-unsigned:22> D.31344;
  int D.31345;
  int i;

  i = 0;
  goto <D.21515>;
  <D.21514>:
  {
    struct MonoType * type;

    type = ginst->type_argv[i];
    D.31322 = type->type;
    D.31323 = (int) D.31322;
    switch (D.31323) <default: <D.31343>, case 15: <D.21510>, case 17: <D.21512>, case 18: <D.21511>, case 20: <D.21509>, case 21: <D.21513>, case 29: <D.21507>>
    <D.21507>:
    D.31324 = type->data.klass;
    D.31325 = can_access_type (access_klass, D.31324);
    if (D.31325 == 0) goto <D.31326>; else goto <D.31327>;
    <D.31326>:
    D.31328 = 0;
    return D.31328;
    <D.31327>:
    goto <D.21508>;
    <D.21509>:
    D.31329 = type->data.array;
    D.31330 = D.31329->eklass;
    D.31331 = can_access_type (access_klass, D.31330);
    if (D.31331 == 0) goto <D.31332>; else goto <D.31333>;
    <D.31332>:
    D.31328 = 0;
    return D.31328;
    <D.31333>:
    goto <D.21508>;
    <D.21510>:
    D.31334 = type->data.type;
    D.31335 = mono_class_from_mono_type (D.31334);
    D.31336 = can_access_type (access_klass, D.31335);
    if (D.31336 == 0) goto <D.31337>; else goto <D.31338>;
    <D.31337>:
    D.31328 = 0;
    return D.31328;
    <D.31338>:
    goto <D.21508>;
    <D.21511>:
    <D.21512>:
    <D.21513>:
    D.31339 = mono_class_from_mono_type (type);
    D.31340 = can_access_type (access_klass, D.31339);
    if (D.31340 == 0) goto <D.31341>; else goto <D.31342>;
    <D.31341>:
    D.31328 = 0;
    return D.31328;
    <D.31342>:
    <D.31343>:
    <D.21508>:
  }
  i = i + 1;
  <D.21515>:
  D.31344 = ginst->type_argc;
  D.31345 = (int) D.31344;
  if (D.31345 > i) goto <D.21514>; else goto <D.21516>;
  <D.21516>:
  D.31328 = 1;
  return D.31328;
}


mono_method_can_access_field_full (struct MonoMethod * method, struct MonoClassField * field, struct MonoClass * context_klass)
{
  struct MonoType * D.31347;
  short unsigned int D.31348;
  int D.31349;
  int D.31350;
  gboolean D.31356;
  struct MonoClass * access_class;
  struct MonoClass * member_class;
  int can;

  access_class = method->klass;
  member_class = field->parent;
  D.31347 = field->type;
  D.31348 = D.31347->attrs;
  D.31349 = (int) D.31348;
  D.31350 = D.31349 & 7;
  can = can_access_member (access_class, member_class, context_klass, D.31350);
  if (can == 0) goto <D.31351>; else goto <D.31352>;
  <D.31351>:
  {
    struct MonoClass * nested;

    nested = access_class->nested_in;
    goto <D.21591>;
    <D.21590>:
    D.31347 = field->type;
    D.31348 = D.31347->attrs;
    D.31349 = (int) D.31348;
    D.31350 = D.31349 & 7;
    can = can_access_member (nested, member_class, context_klass, D.31350);
    if (can != 0) goto <D.21589>; else goto <D.31353>;
    <D.31353>:
    nested = nested->nested_in;
    <D.21591>:
    if (nested != 0B) goto <D.21590>; else goto <D.21589>;
    <D.21589>:
  }
  <D.31352>:
  if (can == 0) goto <D.31354>; else goto <D.31355>;
  <D.31354>:
  D.31356 = 0;
  return D.31356;
  <D.31355>:
  can = can_access_type (access_class, member_class);
  if (can == 0) goto <D.31357>; else goto <D.31358>;
  <D.31357>:
  {
    struct MonoClass * nested;

    nested = access_class->nested_in;
    goto <D.21595>;
    <D.21594>:
    can = can_access_type (nested, member_class);
    if (can != 0) goto <D.21593>; else goto <D.31359>;
    <D.31359>:
    nested = nested->nested_in;
    <D.21595>:
    if (nested != 0B) goto <D.21594>; else goto <D.21593>;
    <D.21593>:
  }
  <D.31358>:
  if (can == 0) goto <D.31360>; else goto <D.31361>;
  <D.31360>:
  D.31356 = 0;
  return D.31356;
  <D.31361>:
  D.31356 = 1;
  return D.31356;
}


mono_class_can_access_class (struct MonoClass * source_class, struct MonoClass * target_class)
{
  gboolean D.31363;

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


mono_type_is_valid_enum_basetype (struct MonoType * type)
{
  unsigned char D.31365;
  int D.31366;
  gboolean D.31367;

  D.31365 = type->type;
  D.31366 = (int) D.31365;
  switch (D.31366) <default: <D.31368>, case 2: <D.21605>, case 3: <D.21608>, case 4: <D.21603>, case 5: <D.21604>, case 6: <D.21606>, case 7: <D.21607>, case 8: <D.21609>, case 9: <D.21610>, case 10: <D.21611>, case 11: <D.21612>, case 24: <D.21613>, case 25: <D.21614>>
  <D.21603>:
  <D.21604>:
  <D.21605>:
  <D.21606>:
  <D.21607>:
  <D.21608>:
  <D.21609>:
  <D.21610>:
  <D.21611>:
  <D.21612>:
  <D.21613>:
  <D.21614>:
  D.31367 = 1;
  return D.31367;
  <D.31368>:
  D.31367 = 0;
  return D.31367;
}


mono_class_is_valid_enum (struct MonoClass * klass)
{
  unsigned char D.31370;
  unsigned char D.31371;
  _Bool D.31372;
  long int D.31373;
  long int D.31374;
  struct MonoClass * D.31379;
  int D.21629;
  int iftmp.464;
  int D.21628;
  const char[5] * D.31384;
  unsigned char D.31385;
  int D.31386;
  unsigned char D.31387;
  int D.31388;
  _Bool D.31389;
  _Bool D.31390;
  _Bool D.31391;
  const unsigned char * D.31394;
  unsigned char D.31395;
  int D.31396;
  const unsigned char * D.31397;
  unsigned char D.31398;
  int D.31399;
  _Bool D.31400;
  _Bool D.31401;
  const unsigned char * D.31404;
  unsigned char D.31405;
  int D.31406;
  const unsigned char * D.31407;
  unsigned char D.31408;
  int D.31409;
  _Bool D.31410;
  _Bool D.31411;
  const unsigned char * D.31414;
  unsigned char D.31415;
  int D.31416;
  const unsigned char * D.31417;
  unsigned char D.31418;
  int D.31419;
  const char * D.31421;
  int D.21638;
  int iftmp.465;
  int D.21637;
  const char[7] * D.31426;
  unsigned char D.31427;
  int D.31428;
  unsigned char D.31429;
  int D.31430;
  _Bool D.31431;
  _Bool D.31432;
  _Bool D.31433;
  const unsigned char * D.31436;
  unsigned char D.31437;
  int D.31438;
  const unsigned char * D.31439;
  unsigned char D.31440;
  int D.31441;
  _Bool D.31442;
  _Bool D.31443;
  const unsigned char * D.31446;
  unsigned char D.31447;
  int D.31448;
  const unsigned char * D.31449;
  unsigned char D.31450;
  int D.31451;
  _Bool D.31452;
  _Bool D.31453;
  const unsigned char * D.31456;
  unsigned char D.31457;
  int D.31458;
  const unsigned char * D.31459;
  unsigned char D.31460;
  int D.31461;
  const char * D.31463;
  gboolean D.31464;
  unsigned int D.31465;
  unsigned int D.31466;
  struct MonoType * D.31469;
  short unsigned int D.31470;
  int D.31471;
  int D.31472;
  int D.31477;
  unsigned int D.31482;
  struct MonoClassField * field;
  void * iter;
  gboolean found_base_field;

  try
    {
      iter = 0B;
      found_base_field = 0;
      D.31370 = BIT_FIELD_REF <*klass, 8, 160>;
      D.31371 = D.31370 & 16;
      D.31372 = D.31371 == 0;
      D.31373 = (long int) D.31372;
      D.31374 = __builtin_expect (D.31373, 0);
      if (D.31374 != 0) goto <D.31375>; else goto <D.31376>;
      <D.31375>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "class.c", 9963, "klass->enumtype");
      <D.31376>:
      D.31379 = klass->parent;
      if (D.31379 == 0B) goto <D.31377>; else goto <D.31380>;
      <D.31380>:
      {
        size_t __s1_len;
        size_t __s2_len;

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

          D.31379 = klass->parent;
          __s2 = D.31379->name;
          D.31384 = "Enum";
          D.31385 = MEM[(const unsigned char *)D.31384];
          D.31386 = (int) D.31385;
          D.31387 = *__s2;
          D.31388 = (int) D.31387;
          __result = D.31386 - D.31388;
          {
            D.31389 = __s2_len != 0;
            D.31390 = __result == 0;
            D.31391 = D.31389 & D.31390;
            if (D.31391 != 0) goto <D.31392>; else goto <D.31393>;
            <D.31392>:
            D.31394 = &MEM[(void *)"Enum" + 1B];
            D.31395 = *D.31394;
            D.31396 = (int) D.31395;
            D.31397 = __s2 + 1;
            D.31398 = *D.31397;
            D.31399 = (int) D.31398;
            __result = D.31396 - D.31399;
            D.31400 = __s2_len > 1;
            D.31390 = __result == 0;
            D.31401 = D.31400 & D.31390;
            if (D.31401 != 0) goto <D.31402>; else goto <D.31403>;
            <D.31402>:
            D.31404 = &MEM[(void *)"Enum" + 2B];
            D.31405 = *D.31404;
            D.31406 = (int) D.31405;
            D.31407 = __s2 + 2;
            D.31408 = *D.31407;
            D.31409 = (int) D.31408;
            __result = D.31406 - D.31409;
            D.31410 = __s2_len > 2;
            D.31390 = __result == 0;
            D.31411 = D.31410 & D.31390;
            if (D.31411 != 0) goto <D.31412>; else goto <D.31413>;
            <D.31412>:
            D.31414 = &MEM[(void *)"Enum" + 3B];
            D.31415 = *D.31414;
            D.31416 = (int) D.31415;
            D.31417 = __s2 + 3;
            D.31418 = *D.31417;
            D.31419 = (int) D.31418;
            __result = D.31416 - D.31419;
            <D.31413>:
            <D.31403>:
            <D.31393>:
          }
          D.21628 = __result;
        }
        iftmp.464 = -D.21628;
        goto <D.31420>;
        <D.31383>:
        D.31379 = klass->parent;
        D.31421 = D.31379->name;
        iftmp.464 = __builtin_strcmp (D.31421, "Enum");
        <D.31420>:
        D.21629 = iftmp.464;
      }
      if (D.21629 != 0) goto <D.31377>; else goto <D.31422>;
      <D.31422>:
      {
        size_t __s1_len;
        size_t __s2_len;

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

          D.31379 = klass->parent;
          __s2 = D.31379->name_space;
          D.31426 = "System";
          D.31427 = MEM[(const unsigned char *)D.31426];
          D.31428 = (int) D.31427;
          D.31429 = *__s2;
          D.31430 = (int) D.31429;
          __result = D.31428 - D.31430;
          {
            D.31431 = __s2_len != 0;
            D.31432 = __result == 0;
            D.31433 = D.31431 & D.31432;
            if (D.31433 != 0) goto <D.31434>; else goto <D.31435>;
            <D.31434>:
            D.31436 = &MEM[(void *)"System" + 1B];
            D.31437 = *D.31436;
            D.31438 = (int) D.31437;
            D.31439 = __s2 + 1;
            D.31440 = *D.31439;
            D.31441 = (int) D.31440;
            __result = D.31438 - D.31441;
            D.31442 = __s2_len > 1;
            D.31432 = __result == 0;
            D.31443 = D.31442 & D.31432;
            if (D.31443 != 0) goto <D.31444>; else goto <D.31445>;
            <D.31444>:
            D.31446 = &MEM[(void *)"System" + 2B];
            D.31447 = *D.31446;
            D.31448 = (int) D.31447;
            D.31449 = __s2 + 2;
            D.31450 = *D.31449;
            D.31451 = (int) D.31450;
            __result = D.31448 - D.31451;
            D.31452 = __s2_len > 2;
            D.31432 = __result == 0;
            D.31453 = D.31452 & D.31432;
            if (D.31453 != 0) goto <D.31454>; else goto <D.31455>;
            <D.31454>:
            D.31456 = &MEM[(void *)"System" + 3B];
            D.31457 = *D.31456;
            D.31458 = (int) D.31457;
            D.31459 = __s2 + 3;
            D.31460 = *D.31459;
            D.31461 = (int) D.31460;
            __result = D.31458 - D.31461;
            <D.31455>:
            <D.31445>:
            <D.31435>:
          }
          D.21637 = __result;
        }
        iftmp.465 = -D.21637;
        goto <D.31462>;
        <D.31425>:
        D.31379 = klass->parent;
        D.31463 = D.31379->name_space;
        iftmp.465 = __builtin_strcmp (D.31463, "System");
        <D.31462>:
        D.21638 = iftmp.465;
      }
      if (D.21638 != 0) goto <D.31377>; else goto <D.31378>;
      <D.31377>:
      D.31464 = 0;
      return D.31464;
      <D.31378>:
      D.31465 = klass->flags;
      D.31466 = D.31465 & 24;
      if (D.31466 != 0) goto <D.31467>; else goto <D.31468>;
      <D.31467>:
      D.31464 = 0;
      return D.31464;
      <D.31468>:
      goto <D.21640>;
      <D.21639>:
      D.31469 = field->type;
      D.31470 = D.31469->attrs;
      D.31471 = (int) D.31470;
      D.31472 = D.31471 & 16;
      if (D.31472 == 0) goto <D.31473>; else goto <D.31474>;
      <D.31473>:
      if (found_base_field != 0) goto <D.31475>; else goto <D.31476>;
      <D.31475>:
      D.31464 = 0;
      return D.31464;
      <D.31476>:
      found_base_field = 1;
      D.31469 = field->type;
      D.31477 = mono_type_is_valid_enum_basetype (D.31469);
      if (D.31477 == 0) goto <D.31478>; else goto <D.31479>;
      <D.31478>:
      D.31464 = 0;
      return D.31464;
      <D.31479>:
      <D.31474>:
      <D.21640>:
      field = mono_class_get_fields (klass, &iter);
      if (field != 0B) goto <D.21639>; else goto <D.21641>;
      <D.21641>:
      if (found_base_field == 0) goto <D.31480>; else goto <D.31481>;
      <D.31480>:
      D.31464 = 0;
      return D.31464;
      <D.31481>:
      D.31482 = klass->method.count;
      if (D.31482 != 0) goto <D.31483>; else goto <D.31484>;
      <D.31483>:
      D.31464 = 0;
      return D.31464;
      <D.31484>:
      D.31464 = 1;
      return D.31464;
    }
  finally
    {
      iter = {CLOBBER};
    }
}


mono_generic_class_is_generic_type_definition (struct MonoGenericClass * gklass)
{
  gboolean D.31487;
  struct MonoGenericInst * D.31488;
  struct MonoClass * D.31489;
  struct MonoGenericContainer * D.31490;
  struct MonoGenericInst * D.31491;
  _Bool D.31492;

  D.31488 = gklass->context.class_inst;
  D.31489 = gklass->container_class;
  D.31490 = D.31489->generic_container;
  D.31491 = D.31490->context.class_inst;
  D.31492 = D.31488 == D.31491;
  D.31487 = (gboolean) D.31492;
  return D.31487;
}


mono_class_setup_interface_id (struct MonoClass * class)
{
  unsigned int D.31496;
  unsigned int D.31497;
  unsigned char D.31499;
  short unsigned int D.31501;
  unsigned int D.31504;
  short unsigned int D.31505;

  mono_loader_lock ();
  D.31496 = class->flags;
  D.31497 = D.31496 & 32;
  if (D.31497 != 0) goto <D.31494>; else goto <D.31498>;
  <D.31498>:
  D.31499 = class->byval_arg.type;
  if (D.31499 == 19) goto <D.31494>; else goto <D.31500>;
  <D.31500>:
  D.31499 = class->byval_arg.type;
  if (D.31499 == 30) goto <D.31494>; else goto <D.31495>;
  <D.31494>:
  D.31501 = class->interface_id;
  if (D.31501 == 0) goto <D.31502>; else goto <D.31503>;
  <D.31502>:
  D.31504 = mono_get_unique_iid (class);
  D.31505 = (short unsigned int) D.31504;
  class->interface_id = D.31505;
  <D.31503>:
  <D.31495>:
  mono_loader_unlock ();
}


mono_class_alloc_ext (struct MonoClass * klass)
{
  struct MonoClassExt * D.31506;
  void * D.31509;
  unsigned int class_ext_size.466;
  unsigned int class_ext_size.467;

  D.31506 = klass->ext;
  if (D.31506 == 0B) goto <D.31507>; else goto <D.31508>;
  <D.31507>:
  D.31509 = mono_class_alloc0 (klass, 40);
  klass->ext = D.31509;
  class_ext_size.466 = class_ext_size;
  class_ext_size.467 = class_ext_size.466 + 40;
  class_ext_size = class_ext_size.467;
  <D.31508>:
}


mono_class_setup_interfaces (struct MonoClass * klass, struct MonoError * error)
{
  unsigned char D.31512;
  unsigned char D.31513;
  unsigned char D.31520;
  unsigned char D.31522;
  guint16 iftmp.468;
  struct MonoClass * D.31525;
  short unsigned int D.31529;
  unsigned int D.31530;
  unsigned int D.31531;
  struct MonoImage * D.31532;
  void * D.31533;
  struct MonoClass * D.31534;
  struct MonoType * D.31535;
  struct MonoClass * * D.31536;
  struct MonoClass * D.31537;
  struct MonoClass * D.31538;
  struct MonoClass * * D.31541;
  struct MonoClass * D.31542;
  struct MonoGenericClass * D.31543;
  short unsigned int D.31546;
  int D.31547;
  void * D.31548;
  unsigned int i.469;
  unsigned int D.31550;
  struct MonoClass * * D.31551;
  struct MonoGenericContext * D.31552;
  struct MonoClass * * D.31553;
  struct MonoClass * * D.31554;
  struct MonoClass * D.31555;
  struct MonoClass * D.31556;
  int D.31557;
  gchar * D.31560;
  int D.31561;
  int i;

  mono_error_init (error);
  D.31512 = BIT_FIELD_REF <*klass, 8, 192>;
  D.31513 = D.31512 & 1;
  if (D.31513 != 0) goto <D.31514>; else goto <D.31515>;
  <D.31514>:
  return;
  <D.31515>:
  mono_loader_lock ();
  D.31512 = BIT_FIELD_REF <*klass, 8, 192>;
  D.31513 = D.31512 & 1;
  if (D.31513 != 0) goto <D.31516>; else goto <D.31517>;
  <D.31516>:
  mono_loader_unlock ();
  return;
  <D.31517>:
  D.31520 = klass->rank;
  if (D.31520 == 1) goto <D.31521>; else goto <D.31518>;
  <D.31521>:
  D.31522 = klass->byval_arg.type;
  if (D.31522 != 20) goto <D.31523>; else goto <D.31518>;
  <D.31523>:
  {
    struct MonoType * args[1];

    try
      {
        D.31525 = mono_defaults.generic_ireadonlylist_class;
        if (D.31525 != 0B) goto <D.31526>; else goto <D.31527>;
        <D.31526>:
        iftmp.468 = 2;
        goto <D.31528>;
        <D.31527>:
        iftmp.468 = 1;
        <D.31528>:
        klass->interface_count = iftmp.468;
        D.31529 = klass->interface_count;
        D.31530 = (unsigned int) D.31529;
        D.31531 = D.31530 * 4;
        D.31532 = klass->image;
        D.31533 = mono_image_alloc0 (D.31532, D.31531);
        klass->interfaces = D.31533;
        D.31534 = klass->element_class;
        D.31535 = &D.31534->byval_arg;
        args[0] = D.31535;
        D.31536 = klass->interfaces;
        D.31537 = mono_defaults.generic_ilist_class;
        D.31538 = mono_class_bind_generic_parameters (D.31537, 1, &args, 0);
        *D.31536 = D.31538;
        D.31529 = klass->interface_count;
        if (D.31529 > 1) goto <D.31539>; else goto <D.31540>;
        <D.31539>:
        D.31536 = klass->interfaces;
        D.31541 = D.31536 + 4;
        D.31525 = mono_defaults.generic_ireadonlylist_class;
        D.31542 = mono_class_bind_generic_parameters (D.31525, 1, &args, 0);
        *D.31541 = D.31542;
        <D.31540>:
      }
    finally
      {
        args = {CLOBBER};
      }
  }
  goto <D.31519>;
  <D.31518>:
  D.31543 = klass->generic_class;
  if (D.31543 != 0B) goto <D.31544>; else goto <D.31545>;
  <D.31544>:
  {
    struct MonoClass * gklass;

    D.31543 = klass->generic_class;
    gklass = D.31543->container_class;
    D.31546 = gklass->interface_count;
    klass->interface_count = D.31546;
    D.31529 = klass->interface_count;
    D.31530 = (unsigned int) D.31529;
    D.31531 = D.31530 * 4;
    D.31547 = (int) D.31531;
    D.31548 = mono_class_alloc0 (klass, D.31547);
    klass->interfaces = D.31548;
    i = 0;
    goto <D.21659>;
    <D.21658>:
    D.31536 = klass->interfaces;
    i.469 = (unsigned int) i;
    D.31550 = i.469 * 4;
    D.31551 = D.31536 + D.31550;
    D.31543 = klass->generic_class;
    D.31552 = mono_generic_class_get_context (D.31543);
    D.31553 = gklass->interfaces;
    i.469 = (unsigned int) i;
    D.31550 = i.469 * 4;
    D.31554 = D.31553 + D.31550;
    D.31555 = *D.31554;
    D.31556 = mono_class_inflate_generic_class_checked (D.31555, D.31552, error);
    *D.31551 = D.31556;
    D.31557 = mono_error_ok (error);
    if (D.31557 == 0) goto <D.31558>; else goto <D.31559>;
    <D.31558>:
    D.31560 = monoeg_strdup ("Could not setup the interfaces");
    mono_class_set_failure (klass, 7, D.31560);
    klass->interfaces = 0B;
    return;
    <D.31559>:
    i = i + 1;
    <D.21659>:
    D.31529 = klass->interface_count;
    D.31561 = (int) D.31529;
    if (D.31561 > i) goto <D.21658>; else goto <D.21660>;
    <D.21660>:
  }
  <D.31545>:
  <D.31519>:
  mono_memory_barrier ();
  klass->interfaces_inited = 1;
  mono_loader_unlock ();
}


mono_class_get_fields_lazy (struct MonoClass * klass, void * * iter)
{
  struct MonoClassField * D.31565;
  void * D.31566;
  struct MonoClassField * D.31569;
  unsigned int D.31572;
  unsigned int D.31575;
  struct MonoClassField * D.31576;
  struct MonoClassField * field;

  if (iter == 0B) goto <D.31563>; else goto <D.31564>;
  <D.31563>:
  D.31565 = 0B;
  return D.31565;
  <D.31564>:
  D.31566 = *iter;
  if (D.31566 == 0B) goto <D.31567>; else goto <D.31568>;
  <D.31567>:
  mono_class_setup_basic_field_info_locking (klass);
  D.31569 = klass->fields;
  if (D.31569 == 0B) goto <D.31570>; else goto <D.31571>;
  <D.31570>:
  D.31565 = 0B;
  return D.31565;
  <D.31571>:
  D.31572 = klass->field.count;
  if (D.31572 != 0) goto <D.31573>; else goto <D.31574>;
  <D.31573>:
  D.31569 = klass->fields;
  *iter = D.31569;
  D.31565 = *iter;
  return D.31565;
  <D.31574>:
  D.31565 = 0B;
  return D.31565;
  <D.31568>:
  field = *iter;
  field = field + 16;
  D.31569 = klass->fields;
  D.31572 = klass->field.count;
  D.31575 = D.31572 * 16;
  D.31576 = D.31569 + D.31575;
  if (D.31576 > field) goto <D.31577>; else goto <D.31578>;
  <D.31577>:
  *iter = field;
  D.31565 = *iter;
  return D.31565;
  <D.31578>:
  D.31565 = 0B;
  return D.31565;
}


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


mono_class_full_name (struct MonoClass * klass)
{
  char * D.31580;
  struct MonoType * D.31581;

  D.31581 = &klass->byval_arg;
  D.31580 = mono_type_full_name (D.31581);
  return D.31580;
}


